12/1/2016. Sorting. Savitch Chapter 7.4. Why sort. Easier to search (binary search) Sorting used as a step in many algorithms

Transcription

1 Sorting Savitch Chapter. Why sort Easier to search (binary search) Sorting used as a step in many algorithms

2 Sorting algorithms There are many algorithms for sorting: Selection sort Insertion sort Bubble sort Merge sort Heap sort Radix sort Quick sort Stooge sort Each has its advantages and disadvantages Selection Sort Find the smallest item Put it in the first position Find the nd smallest item Put it in the nd position Find the rd smallest item Put it in the rd position.

3 Example Scan right starting at. is the smallest. Swap and. Scan right starting at 9. is the smallest. Swap 9 and. Scan right starting at. is the smallest. Swap and. Scan right starting at. is the smallest. Swap and. i 9 9 i 9 i 9 i 9 Selection Sort code public void selectionsort(comparable [] array){ int min; for (int i = 0; i < array.length-; i++) { min = i; for (int j = i+; j < array.length; j++){ if (array[j].compareto(array[min]) < 0) min = j; swap(array, min, i); private void swap(comparable[] array, int i, int j){ Comparable temp = array[i]; array[i] = array[j]; array[j] = temp;

4 Selection Sort code public void selectionsort(comparable [] array){ int min; for (int i = 0; i < array.length-; i++) { outer loop min = i; for (int j = i+; j < array.length; j++){ if (array[j].compareto(array[min]) < 0) inner loop min = j; swap(array, min, i); private void swap(comparable[] array, int i, int j){ Comparable temp = array[i]; array[i] = array[j]; array[j] = temp; Selection Sort code public void selectionsort(comparable [] array){ int min; for (int i = 0; i < array.length-; i++) { outer loop min = i; for (int j = i+; j < array.length; j++){ if (array[j].compareto(array[min]) < 0) inner loop min = j; swap(array, min, i); Observation: running time proportional to the square of the number of elements in the array (nested for loops).

5 Selection Sort Example summary of outer loop (without animation): original: 9 smallest is : 9 smallest is : 9 smallest is : 9 smallest is : 9 9 Loop Invariant for Selection Sort public void selectionsort (Comparable [] array){ int min; for (int i = 0; i < array.length-; i++) { min = i; for (int j = i+; j < array.length; j++){ if (array[j].compareto(array[min]) < 0) min = j; swap (array, min, i); Invariant: The elements array[0..i] are in sorted order

6 Properties of selection sort Is it efficient when data is already sorted? Stable? (Does not change the relative order of elements with equal keys). In-place? (Requires no additional memory). Properties of selection sort Is it efficient when data is already sorted? NO. Stable? (Does not change the relative order of elements with equal keys). NO. In-place? (Requires no additional memory). YES.

7 Insertion sort Works the same way you arrange your hand when playing cards. Pick up a card and place it in your hand in the correct position relative to the cards you re already holding. Arranging a hand of cards

8 Arranging a hand of cards K 8 K Insertion Sort K 8

9 Insertion Sort K Insertion Sort K 9

10 Insertion Sort K 8 K 8 K 8 K 8 K Example is sorted Shift nothing. Insert 9. and 9 are sorted. Shift 9 to the right. Insert.,, 9 are sorted. Shift 9,,, to the right. Insert.,,, 9 are sorted. Shift 9,, to the right. Insert

11 Insertion Sort insertion sort partitions the array into two regions: sorted, and unsorted each iteration the sorted part grows by Insertion Sort another example

12 Insertion Sort Algorithm public void insertionsort(comparable[] array) { for (int i = ; i < array.length; i++) { Comparable temp = array[i]; int position = i; // shift larger values to the right while (position > 0 && array[position-].compareto(temp) > 0) { array[position] = array[position ]; position--; // insert the current item array[position] = temp; With a for loop public void insertionsort(comparable[] array) { for (int i = ; i < array.length; i++) { Comparable temp = array[i]; // shift larger values to the right for (int position = i; (position > 0 && array[position-].compareto(temp) > 0); position--) { array[position] = array[position ]; // insert the current item array[position] = temp;

13 Insertion Sort Algorithm public void insertionsort(comparable[] array) { for (int i = ; i < array.length; i++) { Comparable temp = array[i]; int position = i; // shift larger values to the right while (position > 0 && inner loop array[position-].compareto(temp) > 0) { array[position] = array[position ]; position--; // insert the current item array[position] = temp; outer loop Loop Invariant for Insertion Sort public void insertionsort(comparable[] array) { for (int i = ; i < array.length; i++) { Comparable temp = array[i]; int position = i; while (position > 0 && array[position-].compareto(temp) > 0) { array[position] = array[position ]; position--; array[position] = temp; Invariant: array[0 i-] consists of elements originally in array[0 i-] but in sorted order

14 Properties of insertion sort Is it efficient when data is already sorted? Stable? (Does not change the relative order of elements with equal keys). In-place? (Requires no additional memory). Properties of insertion sort Is it efficient when data is already sorted? Yes. Stable? (Does not change the relative order of elements with equal keys). Yes. In-place? (Requires no additional memory). Yes.

15 Bubble Sort Compares neighboring elements, and swaps them if they are not in order Effect: the largest value will bubble to the last position in the array. Repeating the process will bubble the nd to largest value to the nd to last position in the array Bubble sort (First pass) i = 0 j = 0 j = j = j = j = 0

16 Bubble sort (Second pass) i = j = 0 j = j = j = Bubble Sort public void bubblesort (Comparable [] array) { for (int position = array.length-; position>=0; position--) { for (int i = 0 ; i < position; i++) { if (array[i].compareto(array[i+]) > 0) swap(array, i, i+);

17 Bubble Sort public void bubblesort (Comparable [] array) { for (int position = array.length-; position>=0; position--) { for (int i = 0 ; i < position; i++) { if (array[i].compareto(array[i+]) > 0) inner loop swap(array, i, i+); outer loop Properties of bubble sort Is it efficient when data is already sorted? Stable? (Does not change the relative order of elements with equal keys). In-place? (Requires no additional memory).

18 Properties of bubble sort Is it efficient when data is already sorted? Yes. Stable? (Does not change the relative order of elements with equal keys). Yes. In-place? (Requires no additional memory). Yes. In practice usually slower than the other algs we looked at. Bubble Sort public void bubblesort (Comparable [] array) { for (int position = array.length-; position>=0; position--) { for (int i = 0 ; i < position; i++) { if (array[i].compareto(array[i+]) > 0) swap(array, i, i+); Inner Invariant: array[i] is the largest element in the first i elements in the array Outer Invariant: After i iterations the largest i elements are sorted 8

19 IClicker question # After the first iteration of using Selection Sort (low to high) on the array [,,,,, ], we get: A. [,,,,, ] B. [,,,,, ] C. [,,,,, ] D. [,,,,, ] IClicker question # Answer After the first iteration of the outside loop using Selection Sort (low to high) on the array [,,,,, ], we get: A. [,,,,, ] B. [,,,,, ] C. [,,,,, ] D. [,,,,, ] 9

20 IClicker question # Given a trace of the result of each iteration of the inner loop of a sorting algorithm on the array [8,,,,, ]. [, 8,,,, ] [,, 8,,, ] [,,, 8,, ] [,,,, 8, ] [,,,,, 8] Determine which sorting algorithm was used. A. Bubble sort B. Insertion sort C. Selection sort IClicker question # Answer Given a trace of the result of each iteration of the inner loop of a sorting algorithm on the array [8,,,,, ]. [, 8,,,, ] [,, 8,,, ] [,,, 8,, ] [,,,, 8, ] [,,,,, 8] Determine which sorting algorithm was used. A. Bubble sort B. Insertion sort C. Selection sort 0

21 IClicker question # Given a trace of the result of each iteration of the outer loop of a sorting algorithm on the array [8,,,,, ]. [, 8,,,, ] [,, 8,,, ] [,,, 8,, ] [,,,, 8, ] [,,,,, 8] Determine which sorting algorithm was used. A. Bubble sort B. Insertion sort C. Selection sort IClicker question # Answer Given a trace of the result of each iteration of the outer loop of a sorting algorithm on the array [8,,,,, ]. [, 8,,,, ] [,, 8,,, ] [,,, 8,, ] [,,,, 8, ] [,,,,, 8] Determine which sorting algorithm was used. A. Bubble sort B. Insertion sort C. Selection sort

22 Summary All the algorithms we considered have a quadratic running time. There are algorithms that are much more efficient: merge-sort/heap-sort/quick-sort. Let s look at a comparison website.