Sorting. Arranging records according to a specified sequence, such as alphabetically or numerically, from lowest to highest.

Transcription

1 Sorting Arranging records according to a specified sequence, such as alphabetically or numerically, from lowest to highest. Array before sort [0] [] Array after sort [0] [] 2 [2] [2] [] [] [4] [4] [5] [5] [6] 2 [6] [7] [7]

2 Bubblesort 2 Bubblesort is one of the simplest (and one of the least effective) sorting algorithms. Bubble sort compares two values next to each other and exchanges them if necessary to put them in the correct order. There are many variations on bubble sort, but they all examine adjacent pairs. The larger values gradually bubble their way up to the top like air bubbles in water. Several passes throughout an array are necessary to complete the sort.

3 Bubblesort (pass ) [0] [] [2] [] [4] [5] [6] [7]

4 Bubblesort (pass 2) 4 [0] [] [2] [] [4] [5] [6] [7]

5 Bubblesort (pass ) 5 [0] [] [2] [] [4] [5] [6] [7]

6 Bubblesort (pass 4) 6 [0] [] [2] [] [4] [5] [6] [7]

7 Bubblesort (pass 5) 7 [0] [] [2] [] [4] [5] [6] [7]

8 8 Bubblesort (pass 6) Bubblesort (pass 6) [0] [] [2] [] [4] [5] [6] [7]

9 Bubblesort (pass 7) 9 [0] [] [2] [] [4] [5] [6] 2 2 [7]

10 Bubblesort - C Code 0 #include <stdio.h> void display (int *a, unsigned int n) { unsigned int i; printf ("Printing array\n"); for (i = 0; i < n; i++) printf ("%d\n", a[i]); void swap (int *a, int *b) { int tmp; tmp = *a; *a = *b; *b = tmp; void bubblesort (int *a, unsigned int n) { unsigned int i, j; for (i = n - ; i > 0; i--) for (j = 0; j < i; j++) if (a[j] > a[j + ]) swap (a + j, a + j + ); int main () { int numbers[] = {,,,,,,, ; display (numbers, sizeof (numbers) / sizeof (*numbers)); bubblesort (numbers, sizeof (numbers) / sizeof (*numbers)); display (numbers, sizeof (numbers) / sizeof (*numbers)); return 0;

11 Bubblesort - C Code for Accounts To sort customer accounts, we have to change the swap function and the comparison typedef struct { char name[2]; float balance; int accno; CustAccount; void swap (CustAccount * a, CustAccount * b) { CustAccount tmp; tmp = *a; *a = *b; *b = tmp; void bubblesort (CustAccount * a, unsigned int n) { unsigned int i, j; for (i = n - ; i > 0; i--) for (j = 0; j < i; j++) if (strcmp (a[j].name, a[j + ].name) > 0) swap (a + j, a + j + );

12 Bubblesort - C Code for Accounts The pointer to comparison function can be a parameter to the sort function to allow different sort criteria void swap (CustAccount * a, CustAccount * b) { CustAccount tmp; tmp = *a; *a = *b; *b = tmp; void bubblesort (CustAccount * a, unsigned int n, int (*comp) (const CustAccount *, const CustAccount *)) { unsigned int i, j; for (i = n - ; i > 0; i--) for (j = 0; j < i; j++) if (comp (a + j, a + j + ) > 0) swap (a + j, a + j + ); int compaccno (const CustAccount * p, const CustAccount * p2) { return p->accno - p2->accno; int compname (const CustAccount * p, const CustAccount * p2) { return strcmp (p->name, p2->name); CustAccount accounts[] = {... ; bubblesort (accounts, sizeof (accounts) / sizeof (*accounts), compname); bubblesort (accounts, sizeof (accounts) / sizeof (*accounts), compaccno); 2

13 Bubblesort - General Case To perform sort in general case, bubblesort needs two pieces of information: The size of individual array elements The comparison criterion We also have to pass the size to swap void bubblesort (void *base, unsigned int nmemb, unsigned int size, int (*comp) (const void *, const void *)) { unsigned int i, j; for (i = nmemb - ; i > 0; i--) for (j = 0; j < i; j++) if (comp ((char *) base + j * size, (char *) base + (j + ) * size) > 0) swap ((char *) base + j * size, (char *) base + (j + ) * size, size); nmemb base size

14 Bubblesort - swap 4 swap has to swap the contents of two areas of memory, independently of their type Simple implementation is presented below void swap (void *a, void *b, unsigned int size) { char tmp; unsigned int i; for (i = 0; i < size; i++) { tmp = *((char *) a + i); *((char *) a + i) = *((char *) b + i); *((char *) b + i) = tmp;

15 Bubblesort - Example int compaccno (const void *p, const void *p2) { return ((CustAccount *) p)->accno - ((CustAccount *) p2)->accno; int compname (const void *p, const void *p2) { return strcmp (((CustAccount *) p)->name, ((CustAccount *) p2)->name); int compnum (const void *p, const void *p2) { return *((int *) p) - *((int *) p2); CustAccount accounts[] = {... ; int numbers[] = {,,,,,,, ; bubblesort (accounts, sizeof (accounts) / sizeof (*accounts), sizeof (*accounts), compname); bubblesort (accounts, sizeof (accounts) / sizeof (*accounts), sizeof (*accounts), compaccno); bubblesort (numbers, sizeof (numbers) / sizeof (*numbers), sizeof (*numbers), compnum);

16 base qsort size 6 void qsort(void * base, size_t nmemb, size_t size, int (* compar)(const void *, const void *)); qsort sorts an array (beginning at base) of nmemb objects. size describes the size of each element of the array. You must supply a pointer to a comparison function, using the argument compar This permits sorting objects of unknown properties. compar should accept two arguments, each a pointer to an element of the array The result of compar must be negative if the first argument is less than the second, zero if the two arguments match, and positive if the first argument is greater than the second (where less than and greater than refer to what ever arbitrary ordering is appropriate). The array is sorted in place; that is, when qsort returns, the array elements beginning at base have been reordered. nmemb

17 qsort example typedef struct { char name[2]; float balance; int accno; CustAccount; CustAccount accounts[] = {... ; int compaccno (const void *p, const void *p2) { return ((CustAccount *) p)->accno - ((CustAccount *) p2)->accno; int compname (const void *p, const void *p2) { return strcmp (((CustAccount *) p)->name, ((CustAccount *) p2)->name); int main() {... /* sort by name */ qsort (accounts, sizeof (accounts) / sizeof (*accounts), sizeof (*accounts), compname); /* sort by accno */ qsort (accounts, sizeof (accounts) / sizeof (*accounts), sizeof (*accounts), compaccno);... 7

18 Linear Search 8 2 Search for Start from beginning of an array and compare every element one by one

19 9 Binary Search 2 Search for Search for Allows for fast searching in the sorted array We start in the middle and then determine in which half to search further Apply again until key found or remaining area is empty

20 Binary Search - C Code 20 int * binarysearch (int what, int *low, int *high) { while (high > low) { int *middle = low + (high - low) / 2; if (*middle == what) return middle; else if (*middle > what) high = middle; else low = middle + ; return NULL; Pointer to the location just after the last element Pointer to first element of the array void search (int number, int *low, int *high) { if (binarysearch (number, low, high)) printf ("%d found\n",number); else printf ("%d not found\n",number); int main () { int numbers[] = {,,,,,,, ; search (, numbers, numbers + sizeof (numbers) / sizeof (*numbers)); search (, numbers, numbers + sizeof (numbers) / sizeof (*numbers)); search (6, numbers, numbers + sizeof (numbers) / sizeof (*numbers)); return 0;

21 base bsearch size 2 void *bsearch(const void *key, const void *base, size_t nmemb, size_t size, int (*compar)(const void *, const void *)); bsearch searches an array of nmemb objects, the initial member of which is pointed to by base, for a member that matches the object pointed to by key. The size of each member of the array is specified by size. The contents of the array should be in ascending sorted order according to the comparison function referenced by compar. bsearch returns a pointer to a matching member of the array, or NULL if no match is found. If there are multiple elements that match the key, the element returned is unspecified. nmemb

22 bsearch example 22 typedef struct { char name[2]; float balance; int accno; CustAccount; CustAccount accounts[size]; int compaccno (const void *p, const void *p2) { return ((CustAccount *) p)->accno - ((CustAccount *) p2)->accno; int compname (const void *p, const void *p2) { return strcmp (((CustAccount *) p)->name, ((CustAccount *) p2)->name); CustAccount * findbyname (const char *name) { CustAccount reference; strcpy (reference.name, name); return bsearch (&reference, accounts, sizeof (accounts) / sizeof (*accounts), sizeof (*accounts), compname); CustAccount * findbyaccno (int accno) { CustAccount reference; reference.accno = accno; return bsearch (&reference, accounts, sizeof (accounts) / sizeof (*accounts), sizeof (*accounts), compaccno);