Programming II (CS300)

Transcription

1 1 Programming II (CS300) Chapter 12: Sorting Algorithms MOUNA KACEM Spring 2018

2 Outline 2 Last week Implementation of the three tree depth-traversal algorithms Implementation of the BinarySearchTree class (contains and insert operations) Today Exam2 questions review BST: implementation of remove operation Sorting Algorithms Analysis of the selection sort Analysis of the insertion sort Heap sort (may be) Thursday Merge Sort Quick Sort

3 Sorting Algorithms - Introduction 3 Many operations are more efficient by invoking a sorting procedure initially (such as look-up and search operations) Many applications have an output arranged in some sorted order Dictionary: words in a dictionary are sorted Files in a directory are often listed in a sorted order Index of a book is sorted Card catalog in a library is sorted by author and/or title Calendar of events in a schedule generally sorted by date A listing of course offering at a University is generally sorted by department, and then by course number or identifier

4 Sorting Algorithms 4 Input: an array containing N unsorted elements Only objects that implement the Comparable interface can be sorted Output: an array containing the N elements sorted

5 Selection Sort - Overview 5 Selection Sort: Combination of Searching and Sorting Basic idea Starting from position 0 to the index of the last element of the array 1, an inner loop finds the smallest element in the rest of the array (next smallest element), and the outer loop (i.e. first loop) places it in its proper position

6 Selection Sort - Overview 6 a: array of integers Array Positions (indices)

7 Analysis of the Selection Sort 7 Selection sort Short and simple algorithm Looking for the lowest element requires scanning all n elements (this operation takes N 1 comparisons) and then swapping it into the first position of the array. Finding the next lowest element requires scanning the remaining n 1 elements and so on, T(N) = (N 1) + (N 2) = N(N 1) / 2 O(N 2 ) Time complexity: quadratic (O(N 2 )) where N represents the number of elements in the array Simple sort algorithm appropriate for small inputs (for a need to sort a few elements)

8 Insertion Sort - Overview 8 a: array of integers Array Positions (indices)

9 Analysis of the insertion sort 9 Insertion sort Short and simple algorithm Time complexity: quadratic (O(N 2 )) in the worst case, where N represents the number of elements in the array Simple sort algorithm appropriate for small inputs (for a need to sort a few elements)

10 Merge Sort 10 Divide and conquer algorithm Two half size problems are solved recursively. Then, the result is merged to compose the solution for the original problem. When an original problem is divided into two half-size subproblems and each is solved recursively with an O(N) overhead, the resulting divide and conquer algorithm will have a running time of O(N log(n)), where N represents the size of the original problem

11 Merge sort 11 Basic idea: The mergesort algorithm involves three steps 1. If the number of items to sort is 0 or 1, return 2. Recursively sort the first and second halves separately 3. Merge the two sorted halves into a sorted group To claim an O(N log(n)) algorithm, the merging procedure for two sorted arrays should be performed in linear time (O(N))

12 Merge Sort Illustrative example 12 Divide Conquer

13 Heap Sort 13 The heap-sort algorithm consists of two phases 1. Construction phase: Construct a max-heap given N elements Start with an empty heap and move the boundary between the heap and the sequence from left to right, one step at a time. At step i, for i = 1,...,n, expand the heap by adding the element at index i 1 2. Extraction phase Pull out the value in the root successively, creating a new heap with one less element after each extraction step. Start with an empty sequence and move the boundary between the heap and the sequence from right to left, one step at a time. At step i, for i = 1,...,n, remove the maximal element (root) from the heap and store it at index n i.

14 Running Times for Moderate Inputs 14

15 Costs for growth rates = 2 6