Presentation is loading. Please wait.

Presentation is loading. Please wait.

CMSC 2021 Searching and Sorting. CMSC 2022 Review of Searching Linear (sequential) search Linear search on an ordered list Binary search.

Similar presentations


Presentation on theme: "CMSC 2021 Searching and Sorting. CMSC 2022 Review of Searching Linear (sequential) search Linear search on an ordered list Binary search."— Presentation transcript:

1 CMSC 2021 Searching and Sorting

2 CMSC 2022 Review of Searching Linear (sequential) search Linear search on an ordered list Binary search

3 CMSC 2023 Linear Search fig - 14 items cantalope - minimum comparisons = 1 pineapple - maximum comparisons = 13 cherry - on average, 13/2 = 6 to 7 comparisons kiwi lemon apple Not a very efficient search! So, do we watermelon never use it? lime melon orange pear banana tangerine

4 CMSC 2024 Linear Search on An Ordered List apple -14 items banana - minimum comparisons = 1 cantalope - maximum comparisons = 13 cherry - on average, 13/2 = 6 to 7 comparisons fig kiwi So why is a linear search more efficient lemon on an ordered list than an unordered list? lime melon So should we always choose to order a list orange before performing a linear search on it? pear pineapple tangerine watermelon

5 CMSC 2025 Binary Search apple banana cantalope cherry fig kiwi lemon lime melon orange pear pineapple tangerine watermelon

6 CMSC 2026 Binary Search (con’t) Pretty efficient! As the number of items doubles, the number of comparisons increases by only one! So, if it is so efficient, do we always choose to do a binary search?

7 CMSC 2027 Sorting Bubble Sort Selection Sort Merge Sort Quicksort

8 CMSC 2028 CPGATOBCPGATOB Bubble Sort

9 CMSC 2029 How many loops will the bubble sort algorithm have? What will the loop(s) do? Bubble Sort (con’t)

10 CMSC void bubbleSort1(data array[], int numElements) { int pass, i; data temp; for (pass = 1; pass <= (numElements-1); pass++) { for (i = 0; i <= (numElements-2); i++) { if (array[i] > array[i+1]) { temp = array[i]; array[i] = array[i+1]; array[i+1] = temp; }

11 CMSC void bubbleSort2(data array[], int numElements) { int pass, i, swapMade; // swap flag added data temp; pass = 1; swapMade = 1; // initialize to true while ((pass<=(numElements-1)) && (swapMade==1)) { swapMade = 0; // reset to false for (i = 0; i <= (numElements-2); i++) { if (array[i] > array[i+1]) { temp = array[i]; array[i] = array[i+1]; array[i+1] = temp; swapMade = 1; // set to true } pass++; }

12 CMSC CPGATOBCPGATOB Selection Sort

13 CMSC How many loops will the selection sort algorithm have? What will the loop(s) do? Selection Sort (con’t)

14 CMSC // From on-line notes void selection_sort(data A[], index low, index high) { index i, j, min ; data temp ; for (i = low ; i < high ; i++) { min = i ; for (j = i+1 ; j <= high ; j++) { if (A[j] < A[min]) min = j ; } temp = A[min] ; A[min] = A[i] ; A[i] = temp ; }

15 CMSC Merge Sort

16 CMSC Merge Sort is a “divide and conquer” algorithm The array is repeatedly divided in half, then the arrays are repeatedly merged What type of algorithm do you think would be appropriate? Merge Sort (con’t)

17 CMSC // From on-line notes void mergesort(data A[], index low, index high) { index mid ; if (low >= high) return ; mid = (low + high) / 2 ; mergesort(A, low, mid) ; mergesort(A, mid + 1, high) ; merge(A, low, mid, mid + 1, high) ; }

18 CMSC /* Global variable temp must be allocated the same amount of space as the array to be sorted */ data *temp ; void merge(data A[], index low1, index high1, index low2, index high2) { index t, i1, i2 ; /* Sanity check */ assert(low2 == high1 + 1) ;

19 CMSC /* while there are elements in both halves, copy the lowest one */ i1 = low1 ; i2 = low2 ; t = 0 ; while (i1 <= high1 && i2 <= high2) { if (A[i1] < A[i2]) { temp[t] = A[i1] ; i1++ ; t++ ; } else { temp[t] = A[i2] ; i2++ ; t++ ; } } // end while

20 CMSC /* copy any remaining elements */ while (i1 <= high1) { temp[t] = A[i1] ; t++ ; i1++ ; } while (i2 <= high2) { temp[t++] = A[i2++] ; } /* copy the now-sorted elements back into the original array */ for (t = low1; t <= high2; t++) { A[t] = temp[t - low1] ; } } // end function

21 CMSC Quicksort

22 CMSC Quicksort is also a “divide and conquer” algorithm The array is continually divided in half at the pivot point and rearranged Therefore, recursion is a wise choice Quicksort (con’t)

23 CMSC // From on-line notes void quicksort(data A[], index low, index high) { index q ; if (low >= high) return ; q = partition(A, low, high) ; assert(q < high) ; quicksort(A, low, q) ; quicksort(A, q + 1, high) ; }

24 CMSC index partition(data A[], index low, index high) { data x, temp ; index i, j ; i = low - 1; j = high + 1; x = A[low] ; while (1) { /* Find an element less than x */ do { j = j - 1; } while (A[j] > x) ; /* Find an element greater than x */ do { i = i + 1; } while (A[i] < x);

25 CMSC if (i < j) { temp = A[j] ; A[j] = A[i] ; A[i] = temp ; } else { return j; } } // end while } // end function


Download ppt "CMSC 2021 Searching and Sorting. CMSC 2022 Review of Searching Linear (sequential) search Linear search on an ordered list Binary search."

Similar presentations


Ads by Google