C_Kurs_Lekt / C_II_семестр / 12_qsort

¦bsearch, lfind, lsearch, and qsort

<STDLIB.H, SEARCH.H>

¦ bsearch performs a binary search

¦ lfind and lsearch perform a linear search

¦ qsort sorts using the quicksort algorithm

Declaration:

¦ void *bsearch(const void *key, const void *base, size_t nelem,

size_t width, int (*fcmp)(const void*, const void*));

¦ void *lfind(const void *key, const void *base, size_t *num,

size_t width, int (*fcmp)(const void *, const void*));

¦ void *lsearch(const void *key, void *base, size_t *num,

size_t width, int (*fcmp)(const void *, const void *));

¦ void qsort(void *base, size_t nelem,

size_t width, int (*fcmp)(const void *, const void *));

Function¦ What It Does

=========+==============================================================

bsearch ¦ Makes a binary search for the value *key in a table (array) of nelem elements in memory

lfind

¦ Makes a linear search for *key in an array of sequential records

lsearch ¦ Makes a linear search for *key in a table. If *key is not in the table, lsearch appends it (the

search key) to the table.

qsort

¦ Is an implementation of the "median of three" variant of the quicksort algorithm

Argument¦ What It Is/Points To

=========+===========================================================

base

¦ The base (0th element) of the search table

fcmp

¦ A user-defined comparison routine that compares two items

key

¦ and returns a value based on the comparison

¦ The item to be searched for (the search key)

nelem

¦ The number of entries in the table

num

¦ The number of entries in the table

width

¦ The number of bytes in each entry */

int main(void){

int

n

x;

int

= sizeof(list)/sizeof(list[0]);

printf("\n x =

%d\n До сортировки:",n);

for (x

= 0; x < n; x++)

printf("\npc [%d] = %p -> %s",

x,list[x],list[x]);

qsort((void *)list, 5, sizeof(list[0]), sort_function);

printf("\nПосле сортировкии:");

for (x

= 0;

x < n; x++)

printf("\npc [%d] = %p -> %s",

x,list[x],list[x]);

}

return 0;

int sort_function( const void *a, const void *b) {

return( strcmp((char *)a,(char *)b) ); }

x

= 5

pc

До сортировки:

cat

[0]

=

00AA

->

pc

[1]

=

00AE

->

car

pc

[2]

=

00B2

->

cab

pc

[3]

=

00B6

->

cap

pc

[4]

=

00BA

->

can

После сортировкии:

pc

[0]

=

00AA

->

cab

pc

[1]

=

00AE

->

can

pc

[2]

=

00B2

->

cap

pc

[3]

=

00B6

->

car

pc

[4]

=

00BA

->

cat

#include

<stdio.h>

#include

<conio.h>

#include

<stdlib.h> /* Для функции qsort() */

#include

<string.h> /* Для сравнения строк:

strcmp()

*/

/* Определение функции для сравнения: */

int compare(const void *a, const void *b) {

unsigned long *pa = (unsigned long *)a, *pb = (unsigned long *)b;

return

strcmp((char *)*pa, (char *)*pb);

//

printf(" p= %p a = %s \n",a,(char *) a);

//}

return strcmp((char *) a, (char *) b);

void

main() {

"One - 1", "Two - 2", "Three - 3", "Four - 4 ",

char *pc[] = {

/*

Размер таблицы:

"Five - 5", "Six - 6", "Seven - 7", "Eight - 8" };

*/

int n = sizeof(pc)/sizeof(pc[0]);

int i ;

clrscr();

%d\n

До сортировки:",n); for (i = 0; i < n; i++)

printf("\n n =

printf("\npc [%d] = %p -> %s",

i,pc[i],pc[i]);

/*

Вызов функции упорядочения: */

qsort((void *)

pc,/* Адрес

начала сортируемой таблицы */

n,/* Число элементов

сортируемой таблицы */

sizeof(pc[0]),

/* Размер одного элемента */

compare /* Имя

функции сравнения (указатель) */ ) ;

printf("\n\n

После сортировки:"); for (i = 0; i < n; i++)

} printf("\npc

[%d]

= %p ->

%s", i,pc[i],pc[i]);

n

=

8

pc

До

сортировки:

One -

1

[0] = 00BA ->

pc

[1] = 00C2 ->

Two -

2

pc

[2] = 00CA ->

Three

- 3

pc

[3] = 00D4 ->

Four - 4

pc

[4] = 00DE ->

Five - 5

pc

[5] = 00E7 ->

Six -

6

pc

[6] = 00EF ->

Seven

- 7

pc

[7] = 00F9 ->

Eight

- 8

pc

После сортировки:

->

Eight - 8

[0]

=

00F9

pc

[1]

=

00DE

->

Five - 5

pc

[2]

=

00D4

->

Four - 4

pc

[3]

=

00BA

->

One - 1

pc

[4]

=

00EF

->

Seven - 7

pc

[5]

=

00E7

->

Six - 6

pc

[6]

=

00CA

->

Three - 3

pc

[7]

=

00C2

->

Two – 2

void main() {

stud

its[5]={ {"Петров",21},{"Иванов", 20}, {"Сидоров", 18},

int i,

{"Галкина",17},{"Синичкина", 18}};

n = sizeof(its)/sizeof(its[0]);

clrscr();

%d\n До сортировки:",n);

printf("\n n =

i,&its[i],its[i].fio);

for (i

= 0;

i < n; i++) printf("\nits[%d] = %p -> %s",

qsort((void

*) its, n, sizeof(its[0]), compare ) ;

printf("\n\n

После сортировки:");

} for (i

= 0;

i < n; i++) printf("\nits[%d] = %p -> %s",

i,&its[i],its[i].fio);

n = 5

До сортировки:

Петров

its[0]

=

FFA0 ->

its[1]

=

FFB1 ->

Иванов

its[2]

=

FFC2 ->

Сидоров

its[3]

=

FFD3 ->

Галкина

its[4]

=

FFE4 ->

Синичкина

typedef struct

{ char *fio; int old; }

stud;

/* Определение функции для сравнения строк в структуре */

int compare(const void *a, const void *b) {

stud

**pa

= (stud **)a, **pb = (stud **)b;

return strcmp((char *) (*pa)->fio, (char *) (*pb)->fio ); }

/* Определение функции для сравнения чисел в структуре */

int compare2(const void *a, const void *b) {

stud

**pa

= (stud **)a, **pb = (stud **)b;

if(

(*pa)->old == (*pb)->old ) return 0;

if(

(*pa)->old < (*pb)->old ) return -1;

}

if(

(*pa)->old > (*pb)->old ) return +1;

void main() {

stud *its[5];

int i,

n = sizeof(its)/sizeof(its[0]);

clrscr();

i < n; i++) its[i]=(stud *)calloc(1,sizeof(stud));

for (i

= 0;

its[0]->fio="Петров";

its[0]->old =18;

its[1]->fio="Иванов";

its[1]->old =19;

its[2]->fio="Сидоров";

its[2]->old =18;

its[3]->fio="Галкина";

its[3]->old =21;

its[4]->fio="Синичкина";its[4]->old =16;

printf("\n n =

%d\n

До сортировки:",n);

for (i

= 0;

i < n; i++)

i,its[i],its[i]->fio, its[i]->old);

printf("\nits[%d] = %p -> %-11s %d ",

printf("\n\n

После 1-й сортировки:");

qsort((void

*)

its,

n,

sizeof(its[0]), compare ) ;

for (i

= 0;

i < n; i++)

i,its[i],its[i]->fio, its[i]->old);

printf("\nits[%d] = %p -> %-11s %d ",

qsort((void

*) its,

n,

sizeof(its[0]), compare2 ) ;

printf("\n\n

После 2-й сортировки:");

for (i

= 0;

i < n; i++)

}

printf("\nits[%d] = %p -> %-11s %d ",

i,its[i],its[i]->fio, its[i]->old);

n = 5

До сортировки:

Петров

18

its[0] =

0664

->

its[1] =

066C

->

Иванов

19

its[2] =

0674

->

Сидоров

18

its[3] =

067C

->

Галкина

21

its[4] =

0684

->

Синичкина

16

После 1-й сортировки:

21

its[0] =

067C

->

Галкина

its[1] =

066C

->

Иванов

19

its[2] =

0664

->

Петров

18

its[3] =

0674

->

Сидоров

18

its[4] =

0684

->

Синичкина

16

После 2-й сортировки:

16

its[0] =

0684

->

Синичкина

its[1] =

0674

->

Сидоров

18

its[2] =

0664

->

Петров

18

its[3] =

066C

->

Иванов

19

its[4] =

067C

->

Галкина

21