Sorting. Chapter 12. Exercises

Transcription

1 Chapter 12 Sorting Exercises The sorting algorithm used here could have been straight insertion, selection, or bubble sort because, in this case, these three algorithms give the same result after the first two passes. 9. The algorithm used here is the straight insertion sort because only this sort gives the given sequence after the first two passes. Selection sort gives: Bubble sort gives: After distribution phase: File 1: File 2: After merge: File 3: After distribution phase: File 1: File 2: After merge: File 3: After distribution: File 1: File 2: After merge (Sorted) After sort phase (sort array size of seven): File 1: File 2: File 3: (empty) After merge: File 1: File 2: (empty) File 3:

2 68 Chapter 12 Sorting After first input file rotation: File 1: (empty) File 2: (Sorted) File 3: (empty) Problems 15. See Program PROGRAM 12-1 Solution to Problem 15 /* =============== shellsort ============== List[0], list[1],...list[last] are sorted in place. After the sort, their keys will be in order, list[0].key < list[1].key <..< list[last].key. Pre list is an unordered array of integers last is index to last element in array Post list is ordered Return count of exchanges int shellsort (int* list, int last) int incre; int walker; int count = 0; incre = last / 2; while (incre!= 0) for (int curr = incre; curr <= last; curr++) hold = list [curr]; walker = curr - incre; while (walker >= 0 && hold < list [walker]) // Move larger element up in list list [walker + incre] = list [walker]; // Fall back one partition walker = (walker - incre); // Insert hold in proper relative position list [walker + incre] = hold; } // for walk // End of pass--calculate next increment. incre = incre / 2; return count; } // shellsort

3 Problems See Program PROGRAM 12-2 Solution to Problem 17 /* ==================== heapsort ===================== Sort an array, list[0.. last], using a heap. Pre list must contain at least one item last contains index to last element Post list rearranged smallest to largest Return number of exchanges int heapsort (int* list, int last) int sorted; int holddata; int count = 0; // Create Heap for (int walker = 1; walker <= last; walker++) reheapup (list, walker, &count); // Heap created. Now sort it. sorted = last; while (sorted > 0) holddata = list[0]; list[0] = list[sorted]; list[sorted] = holddata; sorted--; reheapdown (list, 0, sorted, &count); return count; } // heapsort /* ==================== reheapup ======================= Move last entry to correct location in heap array. Pre heap is array last is index to last element count holds number of exchanges Post the array is a valid heap. void reheapup (int* heap, int heaplast, int* count) int parent; if (heaplast!= 0) // if not at root of heap parent = (heaplast - 1) / 2; if (heap[heaplast] > heap[parent]) // child is greater than parent hold = heap[parent]; heap[parent] = heap[heaplast]; heap[heaplast] = hold; reheapup (heap, parent, count);

4 70 Chapter 12 Sorting PROGRAM 12-2 Solution to Problem 17 (continued) heaplast!= 0 } // reheapup /* ==================== reheapdown =================== Move root of tree or subtree down by replacing it with the larger of its two children. Pre heaps is array of data current is root of heap or subheap heaplast is index of last element in heap count is to hold the number of exchanges Post heap structure is valid. void reheapdown (int* heap, int current, int heaplast, int* count) int leftkey; int rightkey; int largechildkey; int largechildindex; if ((current * 2 + 1) <= heaplast) leftkey = heap[current * 2 + 1]; if ((current * 2 + 2) <= heaplast) rightkey = heap[current * 2 + 2]; else rightkey = -1; // Determine which child is larger if (leftkey > rightkey) largechildkey = leftkey; largechildindex = current * 2 + 1; leftkey > rightkey else largechildkey = rightkey; largechildindex = current * 2 + 2; } // else // Test if current > larger subtree if (heap[current] < largechildkey) hold = heap[current]; heap[current] = largechildkey; heap[largechildindex] = hold; reheapdown (heap, largechildindex, heaplast, count); parent < child at least one child } // reheapdown

5 Problems See Program PROGRAM 12-3 Solution to Problem 19 /* ================== quicksort ===================== Array data[left..right] sorted using recursion. Pre data is array to be sorted left identifies first element in data right identifies last element in data count is exchange accumulator Post array sorted void quicksort (int *data, int left, int right, int* count) #define MIN_SIZE 4 int sortleft; int sortright; int pivot; if ((right - left) > MIN_SIZE) medianleft (data, left, right, count); pivot = data [left]; sortleft = left + 1; sortright = right; while (sortleft <= sortright) // Find key on left that belongs on right while (data [sortleft] < pivot) sortleft++; // Find key on right that belongs on left while (data[sortright] >= pivot) sortright--; if (sortleft <= sortright) hold = data[sortleft]; data[sortleft] = data[sortright]; data[sortright] = hold; sortleft++; sortright--; // Prepare for next phase data [left] = data [sortleft - 1]; data [sortleft - 1] = pivot; if (left < sortright) quicksort (data, left, sortright - 1, count); if (sortleft < right) quicksort (data, sortleft, right, count); > minimum elements else quickinsertion (data, left, right, count); } // end quicksort /* ================== quickinsertion ================== Sort list[first...last] using insertion sort. The

6 72 Chapter 12 Sorting PROGRAM 12-3 Solution to Problem 19 (continued) list is divided into sorted and unsorted lists. With each pass, first element in the unsorted list is inserted into the sorted list using a variation of insertion sort modified for use in quick sort. Pre list must contain at least one element first is index to first element last is index to last element count holds the number of exchanges Post list rearranged. void quickinsertion (int* sortdata, int first, int last, int* count) int walker; for (int current = first + 1; current <= last; current++) hold = sortdata[current]; walker = current - 1; while (walker >= first && hold < sortdata[walker]) sortdata[walker + 1] = sortdata[walker]; walker--; sortdata[walker + 1] = hold; } // for } // end quickinsertion /* =================== medianleft ==================== Find median value in array, sortdata[left..right], and place it in the location sortdata[left]. Pre sortdata is array of at least 3 elements left and right are boundaries of the array Post median value placed at sortdata[left count holds the number of exchanges void medianleft (int* sortdata, int left, int mid; int right, int* count) // Rearrange sortdata so median is in middle mid = (left + right) / 2; if (sortdata[left] > sortdata[mid]) hold = sortdata[left]; sortdata[left] = sortdata[mid]; sortdata[mid] = hold; *count += 3; if (sortdata[left] > sortdata[right]) hold = sortdata[left]; sortdata[left] = sortdata[right];

7 Problems 73 PROGRAM 12-3 Solution to Problem 19 (continued) sortdata[right] = hold; if (sortdata[mid] > sortdata[right]) hold = sortdata[mid]; sortdata[mid] = sortdata[right]; sortdata[right] = hold; count += 3; // Median is in middle. Exchange with left hold = sortdata[left]; sortdata[left] = sortdata[mid]; sortdata[mid] = hold; count += 3; } // medianleft 21. See Program PROGRAM 12-4 Solution to Problem 21 /* =================== sortadt ==================== This is a generic sort algorithm. It uses the basic insertion sort. Pre ary contains unsorted data of unknown type Post ary is sorted Return true if successful, false if memory overflow bool sortadt (void* ary, int sizeofelem, int numelem, char* hold; char* pwalk; char* plast; int (*compare)(void* arg1, void* arg2)) hold = (char*) malloc(sizeofelem); if (!hold) return false; plast = (char*)ary + (numelem * sizeofelem); for (char* pary = (char*)ary + sizeofelem; pary < plast; pary += sizeofelem) // Move current to hold area for (int i = 0; i < sizeofelem; i++) *(hold + i) = *(pary + i); for (pwalk = pary - sizeofelem; ((pwalk >= ary) && (compare(hold, pwalk) < 0)); pwalk -= sizeofelem) // Move current up one location for (int i = 0; i < sizeofelem; i++) *(pwalk + (sizeofelem + i)) = *(pwalk + i); } // for walker // Move hold area current location for (int i = 0; i < sizeofelem; i++)

8 74 Chapter 12 Sorting PROGRAM 12-4 Solution to Problem 21 (continued) *(pwalk +sizeofelem + i) = *(hold + i); } // for current free (hold); return true; } // sortadt 23. See Program PROGRAM 12-5 Solution to Problem 23 /* ============= recursiveselsort =============== recursively sorts list[first...last] by selecting smallest element in unsorted portion of array and exchanging it with element at the beginning of the unsorted list. Pre list must contain at least one item. first is index to first element last is index to last element Post list rearranged smallest to largest void recursiveselsort (int* list, int first, int last) int smallest; int holddata; if (first >= last) smallest = first; for (int walker = first + 1; walker <= last; walker++) if (list[ walker ] < list[ smallest ]) smallest = walker; // Smallest selected: exchange with current holddata = list[first]; list[first] = list[smallest]; list[smallest] = holddata; recursiveselsort(list, first + 1, last); } // recursiveselsort