Data Structures And Algorithms

Transcription

1 Data Structures And Algorithms Efficient Sorting Algorithms Eng. Anis Nazer First Semester

2 Efficient Sorting Simple sorting complexity Efficient sorting complexity O(n 2 ) O(nlg n) Merge sort Quick sort

3 Divide an Conquer It is a recursive process Algorithm: split array in half sort left half (using merge sort) sort right half (using merge sort) merge sorted parts

4 Example:

5 split in half:

6 sort left half, using merge sort

7 split left half

8 sort left using merge sort

9 split array

10 sort left, 2 elements, simple case

11 sort right half, 1 element already sorted

12 merge left and right

13 sort right half, 2 elements, simple case

14 merge left and right

15 sort right

16 split in half

17 sort left, 2 elements, simple case

18 sort right, 2 elements, simple case

19 merge left and right

20 merge left and right

21 How to merge two sorted arrays We need another array to store the merged array A and B are sorted, merge them into C A B C

22 we need three counters, i=0, j=0, k=0 Algorithm: while A and B contain elements if (A[ i ] < B[ j ] ) C[ k++ ] = A[ i++]; else C[ k++ ] = B[ j++ ]; copy remaining elements of either A or B into C

23 Implementation two functions mergesort(): takes the Array and the index of the first and last elements and sorts the array. prototype: void mergesort(t A[ ], int first, int last); merge(): takes two sorted arrays and their sizes and merges them. prototype: void merge(t A [ ], int n1, T B[ ], int n2)

24 Implementation template <typename T> void merge(t A[], int n1, T B[], int n2) { T *C = new T[n1+n2]; int i=0, j=0, k=0; while( i < n1 && j < n2 ) { if ( A[i] < B[j] ) C[k++] = A[i++]; else C[k++] = B[j++]; } if ( i == n1 ) { while ( j<n2 ) C[k++] = B[j++]; } else { while ( i<n1 ) C[k++] = A[i++]; } for (k = 0; k < n1+n2; k++) A[k] = C[k]; delete [] C; } template <typename T> void mergesort(t X[], int first, int last) { if ( last == first + 1 ) { if ( X[first] > X[last] ) { T temp = X[first]; X[first] = X[last]; X[last] = temp; } } else if ( first < last ) { int mid = (first+last)/2; int n1 = mid first + 1; int n2 = last mid; mergesort(x,first, mid); mergesort(x, mid+1, last); merge(&x[first], n1, &X[mid+1], n2 ); } }

25 Quick Sort Divide an Conquer It is a recursive process Algorithm: choose a bound, could be the middle element put all elements lower than bound to the left of bound and all elements larger than bound to the right of bound sort left part (using quick sort) sort right part (using quick sort)

26 implementation template<typename T> void quicksort(t A[ ], int first, int last) { int M = (first + last)/2; T pivot = A[M] ; swap( A[first], A[M] ); int L = first + 1, U = last; while ( L <= U ) { while ( pivot > A[L] ) L++; while ( pivot < A[U] ) U ; if ( L < U ) swap( A[L++], A[U ] ); else L++; } swap ( A[first], A[U] ); if ( first < U 1 ) quicksort(a, first, U 1 ); if ( U+1 < last ) quicksort(a, U+1, last); }

27 Example example: sort the following array quicksort(a, 0, 7) first = 0 last = 7 m = 3 bound = A[m] = 7

28 quicksort(a, 0, 7) first = 0 last = 7 m = 3 pivot = A[m] = 7 swap(a[first], A[m]) L=first+1, U=last while(pivot>a[l]) L++; while(pivot<a[u]) U ; swap(a[l++], A[U ]) L U L U L U L U

29 while(pivot>a[l]) L++; while(pivot<a[u]) U ; swap(a[l++], A[U ]) swap(a[first], A[U]) L U L U U L U L now, pivot is in its final position, so we need to sort left side of pivot quicksort(a, first, U 1) quicksort(a, 0, ) sort right side of pivot quicksort(a, U+1, last) quicksort(a, 6, 7)

30 sort left side of pivot quicksort(a, first, U 1) quicksort(a, 0, ) first = 0 last = m = 2 bound pivot = A[m] = swap(a[first], A[m]) L=first+1, U=last while(pivot>a[l]) L++; while(pivot<a[u]) U ; swap(a[l++], A[U ]) U L L U L U L U L U

31 while(pivot>a[l]) L++; while(pivot<a[u]) U ; swap(a[first], A[U]) L U U L U L now, pivot is in its final position, so we need to sort left side of pivot, one element already sorted then sort right side of pivot quicksort(a, U+1, last) quicksort(a, 2, )

32 sort right side of pivot quicksort(a, U+1, last) quicksort(a, 2, ) first = 2 last = m = 3 pivot = A[m] = 5 swap(a[first, A[m]) L=first+1, U=last while (pivot>a[l]) L++; while (pivot<a[u]) U ; U L L U L U U L

33 swap (A[first], A[U]) U L now, pivot is in its final position, so we need to sort left side of pivot, no elements then sort right side of pivot quicksort(a, U+1, last) quicksort(a, 3, ), two element simple case now return to quicksort(a, 6, 7) this is a simple case (two elements)

34 Problem If bound is the largest element in the array, L goes past the array limits... Solution: before starting the quicksort algorithm find the largest element and place it in the last position then: quicksort(a, 0, size-2)

35 Implementation template<typename T> void quicksort(t A[], int size) { if ( size < 2 ) return; else { // find maximum int m = 0; for ( int i = 1; i < size ; i++ ) if ( A[i] > A[m] ) m = i; swap(a[m], A[size 1] ); quicksort(a, 0, size 2); } }

36 Quicksort Quicksort is not efficient for arrays of small sizes We can use other sorting algorithms for smaller size: quicksort2 (array[]) { if ( length of array > 30 ) partition array into subarray1 and subarray2 ; quicksort2(subarray1 ); quicksort2(subarray2 ); else insertionsort(array); }