Sorting Algorithms Merge Sort Quick Sort Hairong Zhao New Jersey Institute of Technology.

Slides:



Advertisements
Similar presentations
Algorithms Analysis Lecture 6 Quicksort. Quick Sort Divide and Conquer.
Advertisements

Comp 122, Spring 2004 Divide and Conquer (Merge Sort)
1 Divide & Conquer Algorithms. 2 Recursion Review A function that calls itself either directly or indirectly through another function Recursive solutions.
Stephen P. Carl - CS 2421 Recursive Sorting Algorithms Reading: Chapter 5.
Divide and Conquer Technique General Method:  The Divide and Conquer Technique splits n inputs into k subsets, 1< k ≤ n, yielding k subproblems.  These.
Chapter 4: Divide and Conquer Master Theorem, Mergesort, Quicksort, Binary Search, Binary Trees The Design and Analysis of Algorithms.
21/3/00SEM107- Kamin & ReddyClass 15 - Recursive Sorting - 1 Class 15 - Recursive sorting methods r Processing arrays by recursion r Divide-and-conquer.
Lecture 2: Divide and Conquer algorithms Phan Thị Hà Dương
DIVIDE AND CONQUER APPROACH. General Method Works on the approach of dividing a given problem into smaller sub problems (ideally of same size).  Divide.
Quicksort CSE 331 Section 2 James Daly. Review: Merge Sort Basic idea: split the list into two parts, sort both parts, then merge the two lists
Efficient Sorts. Divide and Conquer Divide and Conquer : chop a problem into smaller problems, solve those – Ex: binary search.
Analysis of Algorithms CS 477/677 Sorting – Part B Instructor: George Bebis (Chapter 7)
Spring 2015 Lecture 5: QuickSort & Selection
CSC2100B Quick Sort and Merge Sort Xin 1. Quick Sort Efficient sorting algorithm Example of Divide and Conquer algorithm Two phases ◦ Partition phase.
25 May Quick Sort (11.2) CSE 2011 Winter 2011.
Introduction to Algorithms Chapter 7: Quick Sort.
1 Today’s Material Divide & Conquer (Recursive) Sorting Algorithms –QuickSort External Sorting.
Quicksort, Mergesort, and Heapsort. Quicksort Fastest known sorting algorithm in practice  Caveats: not stable  Vulnerable to certain attacks Average.
Sorting Algorithms and Average Case Time Complexity
Updated QuickSort Problem From a given set of n integers, find the missing integer from 0 to n using O(n) queries of type: “what is bit[j]
CS 162 Intro to Programming II Quick Sort 1. Quicksort Maybe the most commonly used algorithm Quicksort is also a divide and conquer algorithm Advantage.
Quick Sort. 2 Divide: Pick any element p as the pivot, e.g, the first element Partition the remaining elements into FirstPart, which contains all elements.
COMP 171 Data Structures and Algorithms Tutorial 4 In-Class Exercises: Algorithm Design.
CS 253: Algorithms Chapter 7 Mergesort Quicksort Credit: Dr. George Bebis.
Sorting. Input: A sequence of n numbers a 1, …, a n Output: A reordering a 1 ’, …, a n ’, such that a 1 ’ < … < a n ’
1 Sorting Algorithms (Part II) Overview  Divide and Conquer Sorting Methods.  Merge Sort and its Implementation.  Brief Analysis of Merge Sort.  Quick.
Quicksort. 2 Introduction * Fastest known sorting algorithm in practice * Average case: O(N log N) * Worst case: O(N 2 ) n But, the worst case seldom.
Quicksort CIS 606 Spring Quicksort Worst-case running time: Θ(n 2 ). Expected running time: Θ(n lg n). Constants hidden in Θ(n lg n) are small.
Divide and Conquer Sorting
Sorting Algorithms Bubble Sort Merge Sort Quick Sort Randomized Quick Sort.
Chapter 7 (Part 2) Sorting Algorithms Merge Sort.
CS2420: Lecture 11 Vladimir Kulyukin Computer Science Department Utah State University.
CSE 373 Data Structures Lecture 19
Sorting (Part II: Divide and Conquer) CSE 373 Data Structures Lecture 14.
Quick Sort By: HMA. RECAP: Divide and Conquer Algorithms This term refers to recursive problem-solving strategies in which 2 cases are identified: A case.
Merge Sort. What Is Sorting? To arrange a collection of items in some specified order. Numerical order Lexicographical order Input: sequence of numbers.
1 Designing algorithms There are many ways to design an algorithm. Insertion sort uses an incremental approach: having sorted the sub-array A[1…j - 1],
Quicksort, Mergesort, and Heapsort. Quicksort Fastest known sorting algorithm in practice  Caveats: not stable  Vulnerable to certain attacks Average.
COMP 171 Data Structures and Algorithms Tutorial 3 Merge Sort & Quick Sort.
Sorting CSIT 402 Data Structures II. 2 Sorting (Ascending Order) Input ›an array A of data records ›a key value in each data record ›a comparison function.
1 CSE 373 Sorting 3: Merge Sort, Quick Sort reading: Weiss Ch. 7 slides created by Marty Stepp
CSS106 Introduction to Elementary Algorithms M.Sc Askar Satabaldiyev Lecture 05: MergeSort & QuickSort.
Lecture 7. Solution by Substitution Method T(n) = 2 T(n/2) + n Substitute n/2 into the main equation 2T(n/2) = 2(2(T(n/4)) + n/2) = 4T(n/4) + n And T(n)
Divide-and-Conquer. Outline Introduction Merge Sort Quick Sort Closest pair of points Large integer multiplication.
Concepts of Algorithms CSC-244 Unit 15 & 16 Divide-and-conquer Algorithms ( Binary Search and Merge Sort ) Shahid Iqbal Lone Computer College Qassim University.
 Design and Analysis of Algorithms تصميم وتحليل الخوارزميات (311 عال) Chapter 2 Sorting (insertion Sort, Merge Sort)
PREVIOUS SORTING ALGORITHMS  BUBBLE SORT –Time Complexity: O(n 2 ) For each item, make (n –1) comparisons Gives: Comparisons = (n –1) + (n – 2)
Lecture # 6 1 Advance Analysis of Algorithms. Divide-and-Conquer Divide the problem into a number of subproblems Similar sub-problems of smaller size.
Nothing is particularly hard if you divide it into small jobs. Henry Ford Nothing is particularly hard if you divide it into small jobs. Henry Ford.
Sorting Quick, Merge & Radix Divide-and-conquer Technique subproblem 2 of size n/2 subproblem 1 of size n/2 a solution to subproblem 1 a solution to.
QuickSort. Yet another sorting algorithm! Usually faster than other algorithms on average, although worst-case is O(n 2 ) Divide-and-conquer: –Divide:
Prof. Amr Goneid, AUC1 CSCE 210 Data Structures and Algorithms Prof. Amr Goneid AUC Part 8b. Sorting(2): (n log n) Algorithms.
1 Overview Divide and Conquer Merge Sort Quick Sort.
Sorting – Lecture 3 More about Merge Sort, Quick Sort.
Sorting. 2 The Sorting Problem Input: A sequence of n numbers a 1, a 2,..., a n Output: A permutation (reordering) a 1 ’, a 2 ’,..., a n ’ of the input.
CMPT 238 Data Structures More on Sorting: Merge Sort and Quicksort.
Algorithms Sorting – Part 3.
Advanced Sorting.
Analysis of Algorithms CS 477/677
Quick Sort Divide: Partition the array into two sub-arrays
Algorithm Design & Analysis
Chapter 7 Sorting Spring 14
Chapter 4: Divide and Conquer
Quick Sort (11.2) CSE 2011 Winter November 2018.
Divide and Conquer (Merge Sort)
Lecture No 6 Advance Analysis of Institute of Southern Punjab Multan
CSE 373 Data Structures and Algorithms
CS200: Algorithm Analysis
CSE 332: Sorting II Spring 2016.
Presentation transcript:

Sorting Algorithms Merge Sort Quick Sort Hairong Zhao New Jersey Institute of Technology

2 Overview Divide and Conquer Merge Sort Quick Sort

3 Divide and Conquer 1.Base Case, solve the problem directly if it is small enough 2.Divide the problem into two or more similar and smaller subproblems 3.Recursively solve the subproblems 4.Combine solutions to the subproblems

4 Divide and Conquer - Sort Problem: Input: A[left..right] – unsorted array of integers Output: A[left..right] – sorted in non-decreasing order

5 Divide and Conquer - Sort 1. Base case at most one element (left ≥ right), return 2. Divide A into two subarrays: FirstPart, SecondPart Two Subproblems: sort the FirstPart sort the SecondPart 3. Recursively sort FirstPart sort SecondPart 4. Combine sorted FirstPart and sorted SecondPart

6 Overview Divide and Conquer Merge Sort Quick Sort

7 Merge Sort: Idea Merge Recursively sort Divide into two halves FirstPart SecondPart FirstPart SecondPart A A is sorted!

8 Merge Sort: Algorithm Merge-Sort (A, left, right) if left ≥ right return else middle ← b (left+right)/2  Merge-Sort(A, left, middle) Merge-Sort(A, middle+1, right) Merge(A, left, middle, right) Recursive Call

9 A[middle] A[left] Sorted FirstPart Sorted SecondPart Merge-Sort: Merge A[right] merge A: A: Sorted

L:R: Temporary Arrays Merge-Sort: Merge Example A:

11 Merge-Sort: Merge Example L: A: R: i=0 j=0 k=

12 Merge-Sort: Merge Example L: A: R: k= i=0 j=1

13 Merge-Sort: Merge Example L: A: R: i=1 k= j=1

14 Merge-Sort: Merge Example L: A: R: i=2 j=1 k=

15 Merge-Sort: Merge Example L: A: R: j=2 k= i=2 5

16 Merge-Sort: Merge Example L: A: R: i=2 j=3 k=

17 Merge-Sort: Merge Example L: A: R: k= i=2 j=4

18 Merge-Sort: Merge Example L: A: R: i=3 j=4 k=7

19 Merge-Sort: Merge Example L: A: R: i=4 j=4 k=8

20 Merge(A, left, middle, right) 1. n 1 ← middle – left n 2 ← right – middle 3. create array L[n 1 ], R[n 2 ] 4. for i ← 0 to n 1 -1 do L[i] ← A[left +i] 5. for j ← 0 to n 2 -1 do R[j] ← A[middle+j] 6. k ← i ← j ← 0 7. while i < n 1 & j < n 2 8. if L[i] < R[j] 9. A[k++] ← L[i++] 10. else 11. A[k++] ← R[j++] 12. while i < n A[k++] ← L[i++] 14. while j < n A[k++] ← R[j++] n = n 1 +n 2 Space: n Time : cn for some constant c

Merge-Sort(A, 0, 7) Divide A:

Merge-Sort(A, 0, 3), divide A: Merge-Sort(A, 0, 7)

Merge-Sort(A, 0, 1), divide A: Merge-Sort(A, 0, 7)

Merge-Sort(A, 0, 0), base case A: Merge-Sort(A, 0, 7)

Merge-Sort(A, 0, 0), return A: Merge-Sort(A, 0, 7)

Merge-Sort(A, 1, 1), base case A: Merge-Sort(A, 0, 7)

Merge-Sort(A, 1, 1), return A: Merge-Sort(A, 0, 7)

Merge(A, 0, 0, 1) A: Merge-Sort(A, 0, 7)

Merge-Sort(A, 0, 1), return A: Merge-Sort(A, 0, 7)

Merge-Sort(A, 2, 3) 4 8, divide A: Merge-Sort(A, 0, 7)

Merge-Sort(A, 2, 2), base case A: Merge-Sort(A, 0, 7)

Merge-Sort(A, 2, 2), return A: Merge-Sort(A, 0, 7)

Merge-Sort(A, 3, 3), base case A: Merge-Sort(A, 0, 7)

Merge-Sort(A, 3, 3), return A: Merge-Sort(A, 0, 7)

Merge(A, 2, 2, 3) A: Merge-Sort(A, 0, 7)

Merge-Sort(A, 2, 3), return A: Merge-Sort(A, 0, 7)

Merge(A, 0, 1, 3) A: Merge-Sort(A, 0, 7)

Merge-Sort(A, 0, 3), return A: Merge-Sort(A, 0, 7)

Merge-Sort(A, 4, 7) A: Merge-Sort(A, 0, 7)

A: Merge (A, 4, 5, 7) Merge-Sort(A, 0, 7)

Merge-Sort(A, 4, 7), return A: Merge-Sort(A, 0, 7)

Merge(A, 0, 3, 7) A: Merge-Sort(A, 0, 7) Merge-Sort(A, 0, 7), done!

43 Merge-Sort Analysis cn 2 × cn/2 = cn 4 × cn/4 = cn n/2 × 2c = cn log n levels Total running time:  (nlogn) Total Space:  (n) Total: cn log n n n/2 n/

44 Merge-Sort Summary Approach: divide and conquer Time Most of the work is in the merging Total time:  (n log n) Space:  (n), more space than other sorts.

45 Overview Divide and Conquer Merge Sort Quick Sort

46 Quick Sort Divide: Pick any element p as the pivot, e.g, the first element Partition the remaining elements into FirstPart, which contains all elements < p SecondPart, which contains all elements ≥ p Recursively sort the FirstPart and SecondPart Combine: no work is necessary since sorting is done in place

47 Quick Sort x < p p p ≤ x Partition FirstPart SecondPart p pivot A: Recursive call x < p p p ≤ x Sorted FirstPart Sorted SecondPart Sorted

48 Quick Sort Quick-Sort(A, left, right) if left ≥ right return else middle ← Partition(A, left, right) Quick-Sort(A, left, middle–1 ) Quick-Sort(A, middle+1, right) end if

49 Partition p p x < pp ≤ x p x < p A: A: A: p

50 Partition ExampleA:

51 Partition ExampleA: i=0 j=1

52 Partition ExampleA: j= i=0 8

53 Partition ExampleA: i=0 j=2

54 Partition ExampleA: i= j=3i=1

55 Partition ExampleA: i=1 5 j=4

56 Partition ExampleA: i=1 1 j=5

57 Partition ExampleA: i=2 16 j=5

58 Partition ExampleA: i= j=6

59 Partition ExampleA: i= i=3j=7

60 Partition ExampleA: i=3 15 j=8

61 Partition ExampleA: 41678i=

62 A: x < 4 4 ≤ x pivot in correct position Partition Example

63 Partition(A, left, right) 1. x ← A[left] 2. i ← left 3. for j ← left+1 to right 4. if A[j] < x then 5. i ← i swap(A[i], A[j]) 7. end if 8. end for j 9. swap(A[i], A[left]) 10. return i n = right – left +1 Time: cn for some constant c Space: constant

Quick-Sort(A, 0, 7) Partition A:

Quick-Sort(A, 0, 7) Quick-Sort(A, 0, 2) A:, partition

Quick-Sort(A, 0, 7) Quick-Sort(A, 0, 0), base case, return

Quick-Sort(A, 0, 7) Quick-Sort(A, 1, 1), base case

Quick-Sort(A, 0, 7) Quick-Sort(A, 2, 2), return Quick-Sort(A, 0, 2), return

Quick-Sort(A, 0, 7) Quick-Sort(A, 2, 2), return Quick-Sort(A, 4, 7), partition

Quick-Sort(A, 0, 7) Quick-Sort(A, 5, 7), partition

Quick-Sort(A, 0, 7) Quick-Sort(A, 6, 7), partition

Quick-Sort(A, 0, 7) Quick-Sort(A, 7, 7) 8, return, base case 8

Quick-Sort(A, 0, 7) Quick-Sort(A, 6, 7), return

Quick-Sort(A, 0, 7) Quick-Sort(A, 5, 7), return 6 8 7

Quick-Sort(A, 0, 7) Quick-Sort(A, 4, 7), return

Quick-Sort(A, 0, 7), done!

77 Quick-Sort: Best Case Even Partition Total time:  (nlogn) cn 2 × cn/2 = cn 4 × c/4 = cn n/3 × 3c = cn log n levels n n/2 n/

78 cn c(n-1) 3c 2c n n-1 n c(n-2) Happens only if input is sortd input is reversely sorted Quick-Sort: Worst Case Unbalanced Partition Total time:  (n 2 )

79 Quick-Sort: an Average Case Suppose the split is 1/10 : 9/10 Quick-Sort: an Average Case cn ≤cn n 0.1n 0.9n 0.01n 0.09n Total time:  (nlogn) 0.81n 2 2 log 10 n log 10/9 n ≤cn

80 Quick-Sort Summary Time Most of the work done in partitioning. Average case takes  (n log(n)) time. Worst case takes  (n 2 ) time Space Sorts in-place, i.e., does not require additional space

81 Summary Divide and Conquer Merge-Sort Most of the work done in Merging  (n log(n)) time  (n) space Quick-Sort Most of the work done in partitioning Average case takes  (n log(n)) time Worst case takes  (n 2 ) time  (1) space

82 Homework 1. What is the running time of Merge-Sort if the array is already sorted? What is the best case running time of Merge-Sort? 2. Demonstrate the working of Partition on sequence (13, 5, 14, 11, 16, 12, 1, 15). What is the value of i returned at the completion of Partition?