DATA STRUCTURES AND ALGORITHMS

Transcription

1 DATA STRUCTURES AND ALGORITHMS Fast sorting algorithms Heapsort, Radixsort

2 Summary of the previous lecture Fast sorting algorithms Shellsort Mergesort Quicksort Why these algorithm is called FAST? What common principle is used for these algorithms? (divide and conquer)

3 Heapsort Heapsort is a comparison-based sorting algorithm, and is based on the selection sort. It is slower algorithm than a well implemented quicksort algorithm. Heapsort has such name because it is based on the heap data structure.

4 What is heap? (reminder) Heap is a almost complete binary tree structure that satisfies the following requirement: if B is a child node of A, then value(a) value(b). This implies that an element with the greatest value is always in the root node. Such heap is sometimes called a max-heap. (Alternatively, if the comparison is reversed, the smallest element is always in the root node, which results in a min-heap.) There is no restriction as to how many children each node has in a heap.

5 Heap example The typical storage method for a heap, or any almost complete binary tree, works as follows: begin by numbering the nodes level by level from the top down, left to right. Assume that we have such array: [100; 19; 36; 17; 3; 25; 1; 2; 7 ] To calculate element indexes: PARENT ( i ) = floor ( i / 2 ); LEFT ( i ) = 2 * i; RIGHT ( i ) = 2*i + 1; P.S. root index = 1

6 Inserting node in the Heap Suppose we have a heap: Add a node with key 15 to the heap: Node swaping:

7 Principle of Heapsort Steps of Heapsort algorthm: 1. Heapsort begins by building a binary-heap out of the data set, and then removing the largest item and placing it at the end of the partially sorted array. 2. After removing the largest item, it reconstructs the heap, removes the largest remaining item, and places it in the next open position from the end of the partially sorted array. 3. This is repeated until there are no items left in the heap and the sorted array is full. Elementary implementations require two arrays - one to hold the heap and the other to hold the sorted elements.

8 To convert array to a heap, first go to the index of the last parent node. This is given by (HeapSize - 2) / 2.

9 HeapSort code void HeapSort (int array[ ], int n) { int i, temp; heap (array,n); // build a heap } } for( i = n-1; i >= 1; i-- ) // put the root node (max) in correct place { temp = array[i]; array[i] = array[0]; array[0] = temp; heap(array, i-1);

10 HeapSort code void heap (int *a, int n) { int i,temp; for( i=n/2; i>=0; i--) { if( a[(2*i)+1] < a[(2*i)+2] && (2*i+1)<=n && (2*i+2)<=n ) { temp = a[(2*i)+1]; a[(2*i)+1] = a[(2*i)+2]; a[(2*i)+2] = temp; } if( a[(2*i)+1] > a[i] && (2*i+1) <=n && i <= n) { temp = a[(2*i)+1]; a[(2*i)+1] = a[i]; a[i] = temp; } } }

11 Heapsort running time Building the heap takes: T(n) = O(n); n deletions of the maximum element each take: T(n) = O(log n); The entire Heapsort operation takes in the worst, average, and best cases : T(n) = O(n log n) Heapsort advantage is that operation time doesn t depend on initial situation in the array. Typically Heapsort is slower than Quicksort, but Heapsort is faster in worst case (Quicksort T(n) = O(n 2 ) in worst case).

12 Radixsort Radix sort is algorithm that sorts integers by processing individual digits, by comparing individual digits sharing the same significant position. Because integers can represent strings of characters (e.g., names or dates), radix sort is not limited only to integers.

13 Example of RadixSort

14 Correctness of Radixsort algorithms Assume we have to numbers: X = 10 i + j; Y = 10 m + n, where 0 <= i, j, m, n <= 9 Inequality X < Y is correct if: i < m or i = m and j < n Radixsort implement these steps, so it means that algorithms produce correct sorting.

15 Radixsort running time Radixsort algorithm requires k passes over the list of n numbers in base r (digits number), with (n + r) work done at each pass. Thus the total work in any case (best or worst) is: T(n) = O(nk + rk). Note that this is not necessarily better than O(n*log(n)), as k may not be independent of n. As an example, consider the ordering of a list of n different integers. Lets assume integers are coded in base B. Then there are B different possible digits and k must be at least as big as logb(n). As there are B different digits, there are B buckets needed, and each pass needs in average n*log 2 (B) comparisons to distribute the integers into the buckets. So: T (n) = n*log 2 (n)

16 Radixsort code #define MAX 10 void Radixsort (int *A, int n) { int i, B[MAX], m = 0, exp = 1; // B[MAX] matrix for temp.storage for (i = 0; i < n; i++) // find the max element { if (A [i] > m) m = A[i]; } while (m / exp > 0) { int bucket [10] = {0}; // why bucket [10]? for( i = 0; i < n; i++ ) bucket [A[i] / exp %10]++; // count elements in buckets for( i = 1; i < 10; i++) bucket [i] = bucket [i] + bucket[i-1]; // define index of last slot for( i = n-1; i >= 0; i--) B [--bucket [A[i] / exp %10] ] = A[i]; for( i = 0; i < n; i++) A[i] = B[i]; exp*=10; } }

17

18 Empirical comparison of Sorting algorithms Limitations of asymptotic analysis of sorting algorithms: Asymptotic complexity analysis lets us distinguish between O(n 2 ) and O(n log n) algorithms, but it does not help distinguish between algorithms with the same asymptotic complexity. Asymptotic analysis say anything about which algorithm is best for sorting small lists.

19 Results of empirical comparison