Survey
* Your assessment is very important for improving the workof artificial intelligence, which forms the content of this project
* Your assessment is very important for improving the workof artificial intelligence, which forms the content of this project
Chapter 9 Sorting Algorithms Data Structures Using Java 1 Chapter Objectives • Learn the various sorting algorithms • Explore how to implement the selection, insertion, quick, merge, and heap sorting algorithms • Discover how the sorting algorithms discussed in this chapter perform • Learn how priority queues are implemented Data Structures Using Java 2 Selection Sort Selection Sort Methodology: 1. Find smallest (or equivalently largest) element in the list 2. Move it to the beginning (or end) of the list by swapping it with element in beginning (or end) position Data Structures Using Java 3 class OrderedArrayList public class OrderedArrayList extends ArrayListClass { public void selectionSort(); { //statements } ... }; Data Structures Using Java 4 Smallest Element in List Function private int minLocation(int first, int last) { int loc, minIndex; minIndex = first; for(loc = first + 1; loc <= last; loc++) if(list[loc] < list[minIndex]) minIndex = loc; return minIndex; }//end minLocation Data Structures Using Java 5 Swap Function private void swap(int first, int second) { DataElement temp; temp = list[first]; list[first] = list[second]; list[second] = temp; }//end swap Data Structures Using Java 6 Selection Sort Function public void selectionSort() { int loc, minIndex; for(loc = 0; loc < length; loc++) { minIndex = minLocation(loc, length - 1); swap(loc, minIndex); } } Data Structures Using Java 7 Selection Sort Example: Array-Based Lists Data Structures Using Java 8 Selection Sort Example: Array-Based Lists Data Structures Using Java 9 Selection Sort Example: Array-Based Lists Data Structures Using Java 10 Selection Sort Example: Array-Based Lists Data Structures Using Java 11 Analysis: Selection Sort Data Structures Using Java 12 Insertion Sort • Reduces number of key comparisons made in selection sort • Can be applied to both arrays and linked lists (examples follow) • Methodology – Find first unsorted element in list – Move it to its proper position Data Structures Using Java 13 Insertion Sort: Array-Based Lists Data Structures Using Java 14 Insertion Sort: Array-Based Lists Data Structures Using Java 15 Insertion Sort: Array-Based Lists Data Structures Using Java 16 Insertion Sort: Array-Based Lists Data Structures Using Java 17 Insertion Sort: Array-Based Lists for(firstOutOfOrder = 1; firstOutOfOrder < length; firstOutOfOrder++) if(list[firstOutOfOrder] is less than list[firstOutOfOrder - 1]) { copy list[firstOutOfOrder] into temp initialize location to firstOutOfOrder do { a. move list[location - 1] one array slot down b. decrement location by 1 to consider the next element of the sorted portion of the array } while(location > 0 && the element in the upper sublist at location - 1 is greater than temp) } copy temp into list[location] Data Structures Using Java 18 Insertion Sort: Array-Based Lists Data Structures Using Java 19 Insertion Sort: Array-Based Lists Data Structures Using Java 20 Insertion Sort: Array-Based Lists Data Structures Using Java 21 Insertion Sort: Array-Based Lists public void insertionSort() { int unsortedIndex, location; DataElement temp; for(unsortedIndex = 1; unsortedIndex < length; unsortedIndex++) if(list[unsortedIndex].compareTo(list[unsortedIndex - 1]) < 0) { temp = list[unsortedIndex]; location = unsortedIndex; do { list[location] = list[location - 1]; location--; }while(location > 0 && list[location - 1].compareTo(temp) > 0); list[location] = temp; } }//end insertionSort Data Structures Using Java 22 Insertion Sort: Linked List-Based List Data Structures Using Java 23 Insertion Sort: Linked List-Based List if(firstOutOfOrder.info is less than first.info) move firstOutOfOrder before first else { set trailCurrent to first set current to the second node in the list //search the list while(current.info is less than firstOutOfOrder.info) { advance trailCurrent; advance current; } if(current is not equal to firstOutOfOrder) { //insert firstOutOfOrder between current and trailCurrent lastInOrder.link = firstOutOfOrder.link; firstOutOfOrder.link = current; trailCurrent.link = firstOutOfOrder; } else //firstOutOfOrder is already at the first place lastInOrder = lastInOrder.link; } Data Structures Using Java 24 Insertion Sort: Linked List-Based List Data Structures Using Java 25 Insertion Sort: Linked List-Based List Data Structures Using Java 26 Insertion Sort: Linked List-Based List Data Structures Using Java 27 Insertion Sort: Linked List-Based List Data Structures Using Java 28 Analysis: Insertion Sort Data Structures Using Java 29 Lower Bound on ComparisonBased Sort Algorithms • Trace execution of comparison-based algorithm by using graph called comparison tree • Let L be a list of n distinct elements, where n > 0. For any j and k, where 1 = j, k = n, either L[j] < L[k] or L[j] > L[k] • Each comparison of the keys has two outcomes; comparison tree is a binary tree • Each comparison is a circle, called a node • Node is labeled as j:k, representing comparison of L[j] with L[k] • If L[j] < L[k], follow the left branch; otherwise, follow the right branch Data Structures Using Java 30 Lower Bound on ComparisonBased Sort Algorithms Data Structures Using Java 31 Lower Bound on ComparisonBased Sort Algorithms • Top node in the figure is the root node • Straight line that connects the two nodes is called a branch • A sequence of branches from a node, x, to another node, y, is called a path from x to y • Rectangle, called a leaf, represents the final ordering of the nodes • Theorem: Let L be a list of n distinct elements. Any sorting algorithm that sorts L by comparison of the keys only, in its worst case, makes at least O(n*log2n) key comparisons Data Structures Using Java 32 Quick Sort • Recursive algorithm • Uses the divide-and-conquer technique to sort a list • List is partitioned into two sublists, and the two sublists are then sorted and combined into one list in such a way so that the combined list is sorted Data Structures Using Java 33 Data Structures Using Java 34 Quick Sort: Array-Based Lists Data Structures Using Java 35 Quick Sort: Array-Based Lists Data Structures Using Java 36 Quick Sort: Array-Based Lists Data Structures Using Java 37 Quick Sort: Array-Based Lists Data Structures Using Java 38 Quick Sort: Array-Based Lists Data Structures Using Java 39 Quick Sort: Array-Based Lists Data Structures Using Java 40 Quick Sort: Array-Based Lists private int partition(int first, int last) { DataElement pivot; int index, smallIndex; swap(first, (first + last) / 2); pivot = list[first]; smallIndex = first; for(index = first + 1; index <= last; index++) if(list[index].compareTo(pivot) < 0) { smallIndex++; swap(smallIndex, index); } swap(first, smallIndex); return smallIndex; }//end partition 9 Data Structures Using Java 41 Quick Sort: Array-Based Lists private void swap(int first, int second) { DataElement temp; temp = list[first]; list[first] = list[second]; list[second] = temp; }//end swap Data Structures Using Java 42 Quick Sort: Array-Based Lists private void recQuickSort(int first, int last) { int pivotLocation; if(first < last) { pivotLocation = partition(first, last); recQuickSort(first, pivotLocation - 1); recQuickSort(pivotLocation + 1, last); } }//end recQuickSort public void quickSort() { recQuickSort(0, length - 1); }//end quickSort Data Structures Using Java 43 Quick Sort: Array-Based Lists Data Structures Using Java 44 Merge Sort • Uses the divide-and-conquer technique to sort a list • Merge sort algorithm also partitions the list into two sublists, sorts the sublists, and then combines the sorted sublists into one sorted list Data Structures Using Java 45 Merge Sort Algorithm Data Structures Using Java 46 Divide Data Structures Using Java 47 Divide Data Structures Using Java 48 Merge Data Structures Using Java 49 Merge Data Structures Using Java 50 Analysis of Merge Sort Suppose that L is a list of n elements, where n > 0. Let A(n) denote the number of key comparisons in the average case, and W(n) denote the number of key comparisons in the worst case to sort L. It can be shown that: A(n) = n*log2n – 1.26n = O(n*log2n) W(n) = n*log2n – (n–1) = O(n*log2n) Data Structures Using Java 51 Heap Sort • Definition: A heap is a list in which each element contains a key, such that the key in the element at position k in the list is at least as large as the key in the element at position 2k + 1 (if it exists), and 2k + 2 (if it exists) Data Structures Using Java 52 Heap Sort: Array-Based Lists Data Structures Using Java 53 Heap Sort: Array-Based Lists Data Structures Using Java 54 Heap Sort: Array-Based Lists Data Structures Using Java 55 Heap Sort: Array-Based Lists Data Structures Using Java 56 Heap Sort: Array-Based Lists Data Structures Using Java 57 Heap Sort: Array-Based Lists Data Structures Using Java 58 Priority Queues: Insertion Assuming the priority queue is implemented as a heap: 1. Insert the new element in the first available position in the list. (This ensures that the array holding the list is a complete binary tree.) 2. After inserting the new element in the heap, the list may no longer be a heap. So to restore the heap: while (parent of new entry < new entry) swap the parent with the new entry Data Structures Using Java 59 Priority Queues: Remove Assuming the priority queue is implemented as a heap, to remove the first element of the priority queue: 1. Copy the last element of the list into the first array position. 2. Reduce the length of the list by 1. 3. Restore the heap in the list. Data Structures Using Java 60 Programming Example: Election Results • The presidential election for the student council of your local university is about to be held. Due to confidentiality, the chair of the election committee wants to computerize the voting. • The chair is looking for someone to write a program to analyze the data and report the winner. • The university has four major divisions, and each division has several departments. For the election, the four divisions are labeled as region 1, region 2, region 3, and region 4. • Each department in each division handles its own voting and directly reports the votes received by each candidate to the election committee. Data Structures Using Java 61 Programming Example: Election Results The voting is reported in the following form: firstName lastName regionNumber numberOfVotes The election committee wants the output in the following tabular form: --------------------Election Results-----------------Votes By Region Candidate Name Rgn#1 Rgn#2 Rgn#3 Rgn#4 Total -------------- --------------------Buddy Balto 0 0 0 272 272 Doctor Doc 25 71 156 97 349 Ducky Donald 110 158 0 0 268 . . . Winner: ???, Votes Received: ??? Total votes polled: ??? Data Structures Using Java 62 Chapter Summary • Sorting Algorithms – – – – – Selection sort Insertion sort Quick sort Merge sort heap sort • Algorithm analysis • Priority queues Data Structures Using Java 63