Computer Programming

Size: px
Start display at page:

Download "Computer Programming"

Transcription

1 Computer Programming Dr. Deepak B Phatak Dr. Supratik Chakraborty Department of Computer Science and Engineering Session: Merge Sort in C++ and Its Analysis Dr. Deepak B. Phatak & Dr. Supratik Chakraborty, 1

2 Quick Recap of Relevant Topics The sorting problem Selection sort Merge sort Intuition Divide-and-conquer strategy Key role of merging sorted sub-arrays 2 Dr. Deepak B. Phatak & Dr. Supratik Chakraborty,

3 Overview of This Lecture Merge sort C++ implementation Analysis of performance Counting basic steps to sort an array of size n 3 Dr. Deepak B. Phatak & Dr. Supratik Chakraborty,

4 Merge Sort: Basic Idea Divide Similar but simpler problem Sort first half of array Similar but simpler problem Sort second half of array Dr. Deepak B. Phatak & Dr. Supratik Chakraborty, 4

5 Sorting by Divide-and-Conquer Divide Sort Similar but simpler problem Sort second half of array Dr. Deepak B. Phatak & Dr. Supratik Chakraborty, 5

6 Sorting by Divide-and-Conquer Divide Sort Merge Sort Dr. Deepak B. Phatak & Dr. Supratik Chakraborty, 6

7 What Were The Steps? Divide an array of size n into two sub-arrays of size n/2 Sub-array sizes may differ by 1 if n is odd Easy! Sort each sub-array of size n/2 Use same technique as for sorting original array (recurse!!!) Termination case of recursion: arrays of size 1 Merge sorted sub-arrays, each of size n/2 One pass over each sorted sub-array Dr. Deepak B. Phatak & Dr. Supratik Chakraborty, 7

8 Merge Sort In C++ int main() { int i, n, A[100]; // Variable declarations cout << Give count of integers: ; cin >> n;// Read and validate inputs if ((n <= 0) (n > 100)) { cout << Invalid input! << endl; return -1; cout << Give << n << integers to sort. << endl; for (i = 0; i < n; i++) { cin >> A[i]; // Read elements of array A mergesort(a, 0, n); // Sort elements A[0] A[n-1] Rest of code return 0; Dr. Deepak B. Phatak & Dr. Supratik Chakraborty, 8

9 Merge Sort In C++ int main() { int i, n, A[100]; // Variable declarations cout << Give count of integers: ; cin >> n;// Read and validate inputs if ((n <= 0) (n > 100)) { cout << Invalid input! << endl; return -1; cout << Give << n << integers to sort. << endl; for (i = 0; i < n; i++) { cin >> A[i]; // Read elements of array A mergesort(a, 0, n); // Sort elements A[0] A[n-1] Rest of code return 0; Dr. Deepak B. Phatak & Dr. Supratik Chakraborty, 9

10 Merge Sort In C++ int main() { int i, n, A[100]; // Variable declarations cout << Give count of integers: ; cin >> n;// Read and validate inputs if ((n <= 0) (n > 100)) { cout << Invalid input! << endl; return -1; cout << Give << n << integers to sort. << endl; for (i = 0; i < n; i++) { cin >> A[i]; // Read elements of array A mergesort(a, 0, n); // Sort elements A[0] A[n-1] Rest of code return 0; Dr. Deepak B. Phatak & Dr. Supratik Chakraborty, 10

11 Merge Sort In C++ // PRECONDITION: start < end, both within array bounds of A void mergesort(int A[], int start, int end) { if (end == start +1) { return; //Subarray of interest has 1 element int mid = (start + end)/2; //Get mid-index of subarray of interest mergesort(a, start, mid); // Sort subarray A[start] A[mid-1] mergesort(a, mid, end); // Sort subarray A[mid] A[end-1] // Merge sorted subarrays A[start] A[mid-1] and A[mid] A[end-1] mergesortedsubarrays(a, start, mid, end); return; // POSTCONDITION: A[start] A[end-1] sorted in decreasing order Dr. Deepak B. Phatak & Dr. Supratik Chakraborty, 11

12 Merge Sort In C++ // PRECONDITION: start < end, both within array bounds of A void mergesort(int A[], int start, int end) { if (end == start +1) { return; //Subarray of interest has 1 element int mid = (start + end)/2; //Get mid-index of subarray of interest mergesort(a, start, mid); // Sort subarray A[start] A[mid-1] mergesort(a, mid, end); // Sort subarray A[mid] A[end-1] // Merge sorted subarrays A[start] A[mid-1] and A[mid] A[end-1] mergesortedsubarrays(a, Termination start, case mid, of end); recursion return; // POSTCONDITION: A[start] A[end-1] sorted in decreasing order Dr. Deepak B. Phatak & Dr. Supratik Chakraborty, 12

13 Merge Sort In C++ // PRECONDITION: start < end, both within array bounds of A void mergesort(int A[], int start, int end) { if (end == start +1) { return; //Subarray of interest has 1 element int mid = (start + end)/2; //Get mid-index of subarray of interest mergesort(a, start, mid); // Sort subarray A[start] A[mid-1] mergesort(a, mid, end); // Sort subarray A[mid] A[end-1] // Merge sorted subarrays A[start] A[mid-1] and A[mid] A[end-1] mergesortedsubarrays(a, start, mid, end); return; // POSTCONDITION: A[start] A[end-1] sorted in decreasing order Dr. Deepak B. Phatak & Dr. Supratik Chakraborty, 13

14 Merge Sort In C++ // PRECONDITION: start < end, both within array bounds of A void mergesort(int A[], int start, int end) { if (end == start +1) { return; //Subarray of interest has 1 element int mid = (start + end)/2; //Get mid-index of subarray of interest mergesort(a, start, mid); // Sort subarray A[start] A[mid-1] mergesort(a, mid, end); // Sort subarray A[mid] A[end-1] // Merge sorted subarrays A[start] A[mid-1] and A[mid] A[end-1] mergesortedsubarrays(a, start, mid, end); return; // POSTCONDITION: A[start] A[end-1] sorted in decreasing order Dr. Deepak B. Phatak & Dr. Supratik Chakraborty, 14

15 Merge Sort In C++ // PRECONDITION: A[start] A[mid-1] and A[mid] A[end-1] sorted in // decreasing order void mergesortedsubarrays(int A[], int start, int mid, int end) { int i, j; int tempa[100], index = start; for (i = start, j = mid; ((i < mid) (j < end)); ) { // Merging loop // Determine whether A[i] or A[j] should appear next in sorted order // Update tempa[index] accordingly index ++; // end of merging loop // Copy tempa[start] tempa[end-1] to A[start] A[end-1] return; // POSTCONDITION: A[start] A[end-1] sorted in decreasing order Dr. Deepak B. Phatak & Dr. Supratik Chakraborty, 15

16 Merge Sort In C++ // PRECONDITION: A[start] A[mid-1] and A[mid] A[end-1] sorted in // decreasing order void mergesortedsubarrays(int A[], int start, int mid, int end) { int i, j; int tempa[100], index = start; for (i = start, j = mid; ((i < mid) (j < end)); ) { // Merging loop Running index for second subarray // Determine whether A[i] or A[j] should appear next in sorted order // Update tempa[index] accordingly A[mid] A[end-1] index ++; // end of merging loop // Copy tempa[start] tempa[end-1] to A[start] A[end-1] Running index for first subarray A[start] A[mid-1] return; // POSTCONDITION: A[start] A[end-1] sorted in decreasing order Dr. Deepak B. Phatak & Dr. Supratik Chakraborty, 16

17 Merge Sort In C++ // PRECONDITION: A[start] A[mid-1] and A[mid] A[end-1] sorted in // decreasing order void mergesortedsubarrays(int A[], int start, int mid, int end) { int i, j; int tempa[100], index = start; for (i = start, j = mid; ((i < mid) (j < end)); ) { // Merging loop // Determine whether A[i] or A[j] should appear next in sorted order // Update tempa[index] accordingly index ++; // end of merging loop // Copy Merged-and-sorted tempa[start] tempa[end-1] subarrayto temporarily A[start] A[end-1] stored in return; tempa[start] tempa[end-1] // POSTCONDITION: A[start] A[end-1] sorted in decreasing order Index in tempa where next element of merged-and-sorted subarray is stored Dr. Deepak B. Phatak & Dr. Supratik Chakraborty, 17

18 Merge Sort In C++ // PRECONDITION: A[start] A[mid-1] and A[mid] A[end-1] sorted in // decreasing order void mergesortedsubarrays(int A[], int start, int mid, int end) { int i, j; int tempa[100], index = start; for (i = start, j = mid; ((i < mid) (j < end)); ) { // Merging loop // Determine whether A[i] or A[j] should appear next in sorted order // Update tempa[index] accordingly index ++; // end of merging loop // Copy tempa[start] tempa[end-1] to A[start] A[end-1] return; // POSTCONDITION: A[start] A[end-1] sorted in decreasing order Dr. Deepak B. Phatak & Dr. Supratik Chakraborty, 18

19 Merging Loop In C++ for (i = start, j = mid; ((i < mid) (j < end)); ) { // Merging loop if ((i < mid) && (j < end)) { // None of the two subarrays fully seen yet // Find if (A[j] which > A[i]) of A[i] {tempa[index] (from subarray = A[j]; A[start] j++; A[mid-1]) or // A[j] else (from {tempa[index] subarray A[mid] = A[i]; A[end-1] i++; is the next sorted element, // copy that element to tempa[index] else { if // (i One < mid) of the {tempa[index] two subarrays = A[i]; fully i++; seen. // A[mid] A[end-1] seen else // Copy if (j elements < end) {tempa[index] from the other = subarray A[j]; j++; to // tempa. A[start] A[mid-1] seen index ++; // end of merging loop Dr. Deepak B. Phatak & Dr. Supratik Chakraborty, 19

20 Merging Loop In C++ for (i = start, j = mid; ((i < mid) (j < end)); ) { // Merging loop if ((i < mid) && (j < end)) { // None of the two subarrays fully seen yet // Find if (A[j] which > A[i]) of A[i] {tempa[index] (from subarray = A[j]; A[start] j++; A[mid-1]) or // A[j] else (from {tempa[index] subarray A[mid] = A[i]; A[end-1] i++; is the next sorted element, // copy that element to tempa[index] else { if //(i One < mid) of the {tempa[index] two subarrays = A[i]; fully i++; seen. // A[mid] A[end-1] seen else // Copy if (j < elements end) {tempa[index] from the other = A[j]; subarray j++; // to A[start] tempa. A[mid-1] seen index ++; // end of merging loop Dr. Deepak B. Phatak & Dr. Supratik Chakraborty, 20

21 Merging Loop In C++ for (i = start, j = mid; ((i < mid) (j < end)); ) { // Merging loop if ((i < mid) && (j < end)) { // None of the two subarrays fully seen yet // Find if (A[j] which > A[i]) of A[i] {tempa[index] (from subarray = A[j]; A[start] j++; A[mid-1]) or // A[j] else (from {tempa[index] subarray A[mid] = A[i]; A[end-1] i++; is the next sorted element, // copy that element to tempa[index] else { if (i < mid) {tempa[index] = A[i]; i++; // A[mid] A[end-1] seen else {tempa[index] = A[j]; j++; // A[start] A[mid-1] seen index ++; // end of merging loop Dr. Deepak B. Phatak & Dr. Supratik Chakraborty, 21

22 Merging Loop In C++ for (i = start, j = mid; ((i < mid) (j < end)); ) { // Merging loop if ((i < mid) && (j < end)) { // None of the two subarrays fully seen yet // Find if (A[j] which > A[i]) of A[i] {tempa[index] (from subarray = A[j]; A[start] j++; A[mid-1]) or // A[j] else (from {tempa[index] subarray A[mid] = A[i]; A[end-1]) i++; is the next sorted element, // copy that element to tempa[index] else { if (i < mid) {tempa[index] = A[i]; i++; // A[mid] A[end-1] seen else {tempa[index] = A[j]; j++; // A[start] A[mid-1] seen index ++; // end of merging loop Dr. Deepak B. Phatak & Dr. Supratik Chakraborty, 22

23 Merging Loop In C++ for (i = start, j = mid; ((i < mid) (j < end)); ) { // Merging loop if ((i < mid) && (j < end)) { // None of the two subarrays fully seen yet if (A[j] > A[i]) {tempa[index] = A[j]; j++; else {tempa[index] = A[i]; i++; else { if (i < mid) {tempa[index] = A[i]; i++; // A[mid] A[end-1] seen else {tempa[index] = A[j]; j++; // A[start] A[mid-1] seen index ++; // end of merging loop Dr. Deepak B. Phatak & Dr. Supratik Chakraborty, 23

24 Merging Loop In C++: The Whole Story for (i = start, j = mid; ((i < mid) (j < end)); ) { // Merging loop if ((i < mid) && (j < end)) { // None of the two subarrays fully seen yet if (A[j] > A[i]) {tempa[index] = A[j]; j++; else {tempa[index] = A[i]; i++; else { if (i < mid) {tempa[index] = A[i]; i++; // A[mid] A[end-1] seen else {tempa[index] = A[j]; j++; // A[start] A[mid-1] seen index ++; // end of merging loop Dr. Deepak B. Phatak & Dr. Supratik Chakraborty, 24

25 Merge Sort In C++ // PRECONDITION: A[start] A[mid-1] and A[mid] A[end-1] sorted in // decreasing order void mergesortedsubarrays(int A[], int start, int mid, int end) { int i, j; int tempa[100], index = start; for (i = start, j = mid; ((i < mid) (j < end)); ) { // Merging loop // Determine for (i = whether start; i A[i] < end; or A[j] i++) should {A[i] appear = tempa[i]; next in sorted order // Update tempa[index] accordingly index ++; // end of merging loop // Copy tempa[start] tempa[end-1] to A[start] A[end-1] return; // POSTCONDITION: A[start] A[end-1] sorted in decreasing order Dr. Deepak B. Phatak & Dr. Supratik Chakraborty, 25

26 Basic Steps in mergesortedsubarrays Reading two array elements, comparing them, writing an element in tempa, incrementing indices Copying an element from tempa to A Dr. Deepak B. Phatak & Dr. Supratik Chakraborty, 26

27 Counting Basic Steps In mergesortedsubarrays Suppose mergesortedsubarrays called with sub-arrays A[start] A[mid-1] and A[mid] A[end-1], each of size n/2 At most n/2 basic steps to iterate over A[start] A[mid-1] At most n/2 basic steps to iterate over A[mid] A[end-1] In all, at most (n/2 + n/2) or n basic steps to get merged sorted subarray in tempa n basic steps to copy tempa[start] tempa[end-1] to A[start] A[end-1] Overall, at most 2n basic steps Dr. Deepak B. Phatak & Dr. Supratik Chakraborty, 27

28 Counting Basic Steps in Merge Sort Let T n denote maximum count of basic steps to merge sort an array of size n Dr. Deepak B. Phatak & Dr. Supratik Chakraborty, 28

29 Merge Sort: Looking Back // PRECONDITION: start < end, both within array bounds of A void mergesort(int A[], int start, int end) { if (end == start +1) { return; //Subarray of interest has 1 element int mid = (start + end)/2; //Get mid-index of subarray of interest mergesort(a, start, mid); // Sort subarray A[start] A[mid-1] mergesort(a, mid, end); // Sort subarray A[mid] A[end-1] // Merge sorted subarrays A[start] A[mid-1] and A[mid] A[end-1] mergesortedsubarrays(a, start, mid, end); return; // POSTCONDITION: A[start] A[end-1] sorted in decreasing order Dr. Deepak B. Phatak & Dr. Supratik Chakraborty, 29

30 Counting Basic Steps in Merge Sort Let Tn denote maximum count of basic steps to merge sort an array of size n T n = T n/2 + T n/2 + 2n mergesortedsubarrays Second recursive call of mergesort First recursive call of mergesort T 1 = 1 Solution of recurrence: T n 2n. log 2 n + n Dr. Deepak B. Phatak & Dr. Supratik Chakraborty, 30

31 Count of basic steps Comparing Basic Steps With Selection Sort Much faster than selection sort for large n Array size Grow as (n-1).(n+2)/2 Grow as 2n.(log n) + n 2 Dr. Deepak B. Phatak & Dr. Supratik Chakraborty, 31

32 Summary Merge sort C++ implementation using recursion Analysis of performance Counting basic steps in sorting an array of size n Clear winner performance-wise over selection sort Dr. Deepak B. Phatak & Dr. Supratik Chakraborty, 32

Computer Programming

Computer Programming Computer Programming Dr. Deepak B Phatak Dr. Supratik Chakraborty Department of Computer Science and Engineering Session: An Example with Sequential and Conditional Execution Dr. Deepak B. Phatak & Dr.

More information

Computer Programming

Computer Programming Computer Programming Dr. Deepak B Phatak Dr. Supratik Chakraborty Department of Computer Science and Engineering Lectures 20, 21, 22 Dr. Deepak B. Phatak & Dr. Supratik Chakraborty, 1 A Generic Iteration

More information

Computer Programming

Computer Programming Computer Programming Dr. Deepak B Phatak Dr. Supratik Chakraborty Department of Computer Science and Engineering Session: for statement in C++ Dr. Deepak B. Phatak & Dr. Supratik Chakraborty, 1 Quick Recap

More information

Computer Programming

Computer Programming Computer Programming Dr. Deepak B Phatak Dr. Supratik Chakraborty Department of Computer Science and Engineering Session: Parameter Passing in Function Calls Dr. Deepak B. Phatak & Dr. Supratik Chakraborty,

More information

Computer Programming

Computer Programming Computer Programming Dr. Deepak B Phatak Dr. Supratik Chakraborty Department of Computer Science and Engineering Session: while and do while statements in C++ Dr. Deepak B. Phatak & Dr. Supratik Chakraborty,

More information

Computer Programming

Computer Programming Computer Programming Dr. Deepak B Phatak Dr. Supratik Chakraborty Department of Computer Science and Engineering Session: Introduction to Pointers Part 1 Dr. Deepak B. Phatak & Dr. Supratik Chakraborty,

More information

Computer Programming

Computer Programming Computer Programming Dr. Deepak B Phatak Dr. Supratik Chakraborty Department of Computer Science and Engineering Session: Iteration Idioms: Motivation Dr. Deepak B. Phatak & Dr. Supratik Chakraborty, 1

More information

CS101 Computer Programming Quiz for Wednesday Batch 8 October 2014

CS101 Computer Programming Quiz for Wednesday Batch 8 October 2014 CS101 Computer Programming Quiz for Wednesday Batch 8 October 2014 Q1. Consider the following variation of Merge Sort to sort the array in descending order. In the version of Merge Sort discussed in class,

More information

Computer Programming

Computer Programming Computer Programming Dr. Deepak B Phatak Dr. Supratik Chakraborty Department of Computer Science and Engineering Session: Pointers and Dynamic Memory Part 1 Dr. Deepak B. Phatak & Dr. Supratik Chakraborty,

More information

Computer Programming

Computer Programming Computer Programming Dr. Deepak B Phatak Dr. Supratik Chakraborty Department of Computer Science and Engineering Session: Recap of Function Calls and Parameter Passing Dr. Deepak B. Phatak & Dr. Supratik

More information

Computer Programming

Computer Programming Computer Programming Dr. Deepak B Phatak Dr. Supratik Chakraborty Department of Computer Science and Engineering Session: Programming using Structures Dr. Deepak B. Phatak & Dr. Supratik Chakraborty, 1

More information

Computer Programming

Computer Programming Computer Programming Dr. Deepak B Phatak Dr. Supratik Chakraborty Department of Computer Science and Engineering Session: Structure of a Simple C++ Program Dr. Deepak B. Phatak & Dr. Supratik Chakraborty,

More information

Computer Programming

Computer Programming Computer Programming Dr. Deepak B Phatak Dr. Supratik Chakraborty Department of Computer Science and Engineering Session: Quiz and Practice Questions on Classes Part 1 Dr. Deepak B. Phatak & Dr. Supratik

More information

Computer Programming

Computer Programming Computer Programming Dr. Deepak B Phatak Dr. Supratik Chakraborty Department of Computer Science and Engineering Session: Recursive Functions Part B Dr. Deepak B. Phatak & Dr. Supratik Chakraborty, 1 Quick

More information

Computer Programming

Computer Programming Computer Programming Dr. Deepak B Phatak Dr. Supratik Chakraborty Department of Computer Science and Engineering Session: Recap of Arrays and Simultaneous Equations (S31 S35) Dr. Deepak B. Phatak & Dr.

More information

Computer Programming

Computer Programming Computer Programming Dr. Deepak B Phatak Dr. Supratik Chakraborty Department of Computer Science and Engineering Session: Character Strings Dr. Deepak B. Phatak & Dr. Supratik Chakraborty, 1 Quick Recap

More information

Computer Programming

Computer Programming Computer Programming Dr. Deepak B Phatak Dr. Supratik Chakraborty Department of Computer Science and Engineering Session : C++ Standard Library The string Class Dr. Deepak B. Phatak & Dr. Supratik Chakraborty,

More information

Lecture 6: Divide-and-Conquer

Lecture 6: Divide-and-Conquer Lecture 6: Divide-and-Conquer COSC242: Algorithms and Data Structures Brendan McCane Department of Computer Science, University of Otago Types of Algorithms In COSC242, we will be looking at 3 general

More information

Introduction to Computers and Programming. Today

Introduction to Computers and Programming. Today Introduction to Computers and Programming Prof. I. K. Lundqvist Lecture 10 April 8 2004 Today How to determine Big-O Compare data structures and algorithms Sorting algorithms 2 How to determine Big-O Partition

More information

Computer Programming

Computer Programming Computer Programming Dr. Deepak B Phatak Dr. Supratik Chakraborty Department of Computer Science and Engineering Session : Concluding Comments on C++ Standard Library Dr. Deepak B. Phatak & Dr. Supratik

More information

Computer Programming

Computer Programming Computer Programming Dr. Deepak B Phatak Dr. Supratik Chakraborty Department of Computer Science and Engineering Session: An Example Program using Member Functions Dr. Deepak B. Phatak & Dr. Supratik Chakraborty,

More information

Lecture 1. Introduction / Insertion Sort / Merge Sort

Lecture 1. Introduction / Insertion Sort / Merge Sort Lecture 1. Introduction / Insertion Sort / Merge Sort T. H. Cormen, C. E. Leiserson and R. L. Rivest Introduction to Algorithms, 3nd Edition, MIT Press, 2009 Sungkyunkwan University Hyunseung Choo choo@skku.edu

More information

8/5/10 TODAY'S OUTLINE. Recursion COMP 10 EXPLORING COMPUTER SCIENCE. Revisit search and sorting using recursion. Recursion WHAT DOES THIS CODE DO?

8/5/10 TODAY'S OUTLINE. Recursion COMP 10 EXPLORING COMPUTER SCIENCE. Revisit search and sorting using recursion. Recursion WHAT DOES THIS CODE DO? 8/5/10 TODAY'S OUTLINE Recursion COMP 10 EXPLORING COMPUTER SCIENCE Revisit search and sorting using recursion Binary search Merge sort Lecture 8 Recursion WHAT DOES THIS CODE DO? A function is recursive

More information

ESc101 : Fundamental of Computing

ESc101 : Fundamental of Computing ESc101 : Fundamental of Computing I Semester 2008-09 Lecture 37 Analyzing the efficiency of algorithms. Algorithms compared Sequential Search and Binary search GCD fast and GCD slow Merge Sort and Selection

More information

CSCI 2132 Software Development Lecture 18: Implementation of Recursive Algorithms

CSCI 2132 Software Development Lecture 18: Implementation of Recursive Algorithms Lecture 18 p.1 Faculty of Computer Science, Dalhousie University CSCI 2132 Software Development Lecture 18: Implementation of Recursive Algorithms 17-Oct-2018 Location: Chemistry 125 Time: 12:35 13:25

More information

Computer Programming

Computer Programming Computer Programming Dr. Deepak B Phatak Dr. Supratik Chakraborty Department of Computer Science and Engineering Session : Template Class list Dr. Deepak B. Phatak & Dr. Supratik Chakraborty, 1 Quick Recap

More information

Divide-and-Conquer. Divide-and conquer is a general algorithm design paradigm:

Divide-and-Conquer. Divide-and conquer is a general algorithm design paradigm: Presentation for use with the textbook Data Structures and Algorithms in Java, 6 th edition, by M. T. Goodrich, R. Tamassia, and M. H. Goldwasser, Wiley, 2014 Merge Sort 7 2 9 4 2 4 7 9 7 2 2 7 9 4 4 9

More information

Data Structure Lecture#17: Internal Sorting 2 (Chapter 7) U Kang Seoul National University

Data Structure Lecture#17: Internal Sorting 2 (Chapter 7) U Kang Seoul National University Data Structure Lecture#17: Internal Sorting 2 (Chapter 7) U Kang Seoul National University U Kang 1 In This Lecture Main ideas and analysis of Merge sort Main ideas and analysis of Quicksort U Kang 2 Merge

More information

Sorting L7.2 Recall linear search for an element in an array, which is O(n). The divide-and-conquer technique of binary search divides the array in ha

Sorting L7.2 Recall linear search for an element in an array, which is O(n). The divide-and-conquer technique of binary search divides the array in ha Lecture Notes on Sorting 15-122: Principles of Imperative Computation Frank Pfenning Lecture 7 February 1, 2011 1 Introduction We have seen in the last lecture that sorted arrays drastically reduce the

More information

CS171 Midterm Exam. October 29, Name:

CS171 Midterm Exam. October 29, Name: CS171 Midterm Exam October 29, 2012 Name: You are to honor the Emory Honor Code. This is a closed-book and closed-notes exam. You have 50 minutes to complete this exam. Read each problem carefully, and

More information

Lecture 6 Sorting and Searching

Lecture 6 Sorting and Searching Lecture 6 Sorting and Searching Sorting takes an unordered collection and makes it an ordered one. 1 2 3 4 5 6 77 42 35 12 101 5 1 2 3 4 5 6 5 12 35 42 77 101 There are many algorithms for sorting a list

More information

Computer Programming

Computer Programming Computer Programming Dr. Deepak B Phatak Dr. Supratik Chakraborty Department of Computer Science and Engineering Session: Computer Architecture Dr. Deepak B. Phatak & Dr. Supratik Chakraborty, 1 Quick

More information

Computer Programming

Computer Programming Computer Programming Dr. Deepak B Phatak Dr. Supratik Chakraborty Department of Computer Science and Engineering Session: Access Control and Introduction to Classes Dr. Deepak B. Phatak & Dr. Supratik

More information

Announcements. Biostatistics 615/815 Lecture 5: More on STLs, and Divide and Conquer Algorithms. Recap on STL : vector.

Announcements. Biostatistics 615/815 Lecture 5: More on STLs, and Divide and Conquer Algorithms. Recap on STL : vector. Announcements Biostatistics 615/815 Lecture 5: More on s, and Algorithms Hyun Min Kang Januray 20th, 2011 Homework #1 is due, late submission will be better than no submission For 815 project, rank your

More information

We can use a max-heap to sort data.

We can use a max-heap to sort data. Sorting 7B N log N Sorts 1 Heap Sort We can use a max-heap to sort data. Convert an array to a max-heap. Remove the root from the heap and store it in its proper position in the same array. Repeat until

More information

Computer Programming

Computer Programming Computer Programming Dr. Deepak B Phatak Dr. Supratik Chakraborty Department of Computer Science and Engineering Session: Inheritance in C++ Dr. Deepak B. Phatak & Dr. Supratik Chakraborty, 1 Overview

More information

Biostatistics 615/815 Lecture 5: Divide and Conquer Algorithms Sorting Algorithms

Biostatistics 615/815 Lecture 5: Divide and Conquer Algorithms Sorting Algorithms Biostatistics 615/815 Lecture 5: Algorithms Algorithms Hyun Min Kang September 20th, 2011 Hyun Min Kang Biostatistics 615/815 - Lecture 5 September 20th, 2011 1 / 30 Recap - An example C++ class #include

More information

CS 112 Introduction to Computing II. Wayne Snyder Computer Science Department Boston University

CS 112 Introduction to Computing II. Wayne Snyder Computer Science Department Boston University 0/6/6 CS Introduction to Computing II Wayne Snyder Department Boston University Today Conclusions on Iterative Sorting: Complexity of Insertion Sort Recursive Sorting Methods and their Complexity: Mergesort

More information

Divide & Conquer. 2. Conquer the sub-problems by solving them recursively. 1. Divide the problem into number of sub-problems

Divide & Conquer. 2. Conquer the sub-problems by solving them recursively. 1. Divide the problem into number of sub-problems Divide & Conquer Divide & Conquer The Divide & Conquer approach breaks down the problem into multiple smaller sub-problems, solves the sub-problems recursively, then combines the solutions of the sub-problems

More information

Sorting. Bringing Order to the World

Sorting. Bringing Order to the World Lecture 10 Sorting Bringing Order to the World Lecture Outline Iterative sorting algorithms (comparison based) Selection Sort Bubble Sort Insertion Sort Recursive sorting algorithms (comparison based)

More information

CS 112 Introduction to Computing II. Wayne Snyder Computer Science Department Boston University

CS 112 Introduction to Computing II. Wayne Snyder Computer Science Department Boston University CS 112 Introduction to Computing II Wayne Snyder Department Boston University Today Recursive Sorting Methods and their Complexity: Mergesort Conclusions on sorting algorithms and complexity Next Time:

More information

Biostatistics 615/815 Lecture 5: More on STLs, and Divide and Conquer Algorithms

Biostatistics 615/815 Lecture 5: More on STLs, and Divide and Conquer Algorithms Biostatistics 615/815 Lecture 5: More on s, and Algorithms Hyun Min Kang Januray 20th, 2011 Hyun Min Kang Biostatistics 615/815 - Lecture 5 Januray 20th, 2011 1 / 28 Announcements Homework #1 is due, late

More information

ESc101 : Fundamental of Computing

ESc101 : Fundamental of Computing ESc101 : Fundamental of Computing I Semester 2008-09 Lecture 36 Announcement : Extra sessions for lab test Sorting algorithms based on recursion Quick Sort (did in lst class) Merge Sort Introduction to

More information

Analyzing Complexity of Lists

Analyzing Complexity of Lists Analyzing Complexity of Lists Operation Sorted Array Sorted Linked List Unsorted Array Unsorted Linked List Search( L, x ) O(logn) O( n ) O( n ) O( n ) Insert( L, x ) O(logn) O( n ) + O( 1 ) O( 1 ) + O(

More information

Recursion. Chapter 7. Copyright 2012 by Pearson Education, Inc. All rights reserved

Recursion. Chapter 7. Copyright 2012 by Pearson Education, Inc. All rights reserved Recursion Chapter 7 Contents What Is Recursion? Tracing a Recursive Method Recursive Methods That Return a Value Recursively Processing an Array Recursively Processing a Linked Chain The Time Efficiency

More information

Lecture 2: Getting Started

Lecture 2: Getting Started Lecture 2: Getting Started Insertion Sort Our first algorithm is Insertion Sort Solves the sorting problem Input: A sequence of n numbers a 1, a 2,..., a n. Output: A permutation (reordering) a 1, a 2,...,

More information

Divide and Conquer 4-0

Divide and Conquer 4-0 Divide and Conquer 4-0 Divide-and-Conquer The most-well known algorithm design strategy: 1. Divide instance of problem into two or more smaller instances 2. Solve smaller instances recursively 3. Obtain

More information

Lecture Notes 14 More sorting CSS Data Structures and Object-Oriented Programming Professor Clark F. Olson

Lecture Notes 14 More sorting CSS Data Structures and Object-Oriented Programming Professor Clark F. Olson Lecture Notes 14 More sorting CSS 501 - Data Structures and Object-Oriented Programming Professor Clark F. Olson Reading for this lecture: Carrano, Chapter 11 Merge sort Next, we will examine two recursive

More information

Algorithm Efficiency & Sorting. Algorithm efficiency Big-O notation Searching algorithms Sorting algorithms

Algorithm Efficiency & Sorting. Algorithm efficiency Big-O notation Searching algorithms Sorting algorithms Algorithm Efficiency & Sorting Algorithm efficiency Big-O notation Searching algorithms Sorting algorithms Overview Writing programs to solve problem consists of a large number of decisions how to represent

More information

DO NOT. UNIVERSITY OF CALIFORNIA Department of Electrical Engineering and Computer Sciences Computer Science Division. P. N.

DO NOT. UNIVERSITY OF CALIFORNIA Department of Electrical Engineering and Computer Sciences Computer Science Division. P. N. CS61B Fall 2013 UNIVERSITY OF CALIFORNIA Department of Electrical Engineering and Computer Sciences Computer Science Division Test #2 Solutions DO NOT P. N. Hilfinger REPRODUCE 1 Test #2 Solution 2 Problems

More information

Computer Programming

Computer Programming Computer Programming Dr. Deepak B Phatak Dr. Supratik Chakraborty Department of Computer Science and Engineering IIT Bombay Session: Advanced Graphics Events Guest Lecturer: Dr. Abhiram Ranade Quick recap

More information

MergeSort, Recurrences, Asymptotic Analysis Scribe: Michael P. Kim Date: September 28, 2016 Edited by Ofir Geri

MergeSort, Recurrences, Asymptotic Analysis Scribe: Michael P. Kim Date: September 28, 2016 Edited by Ofir Geri CS161, Lecture 2 MergeSort, Recurrences, Asymptotic Analysis Scribe: Michael P. Kim Date: September 28, 2016 Edited by Ofir Geri 1 Introduction Today, we will introduce a fundamental algorithm design paradigm,

More information

CSCE 110 Notes on Recursive Algorithms (Part 12) Prof. Amr Goneid

CSCE 110 Notes on Recursive Algorithms (Part 12) Prof. Amr Goneid CSCE 110 Notes on Recursive Algorithms (Part 12) Prof. Amr Goneid 1. Definition: The expression Recursion is derived from Latin: Re- = back and currere = to run, or to happen again, especially at repeated

More information

Sorting. Bubble Sort. Pseudo Code for Bubble Sorting: Sorting is ordering a list of elements.

Sorting. Bubble Sort. Pseudo Code for Bubble Sorting: Sorting is ordering a list of elements. Sorting Sorting is ordering a list of elements. Types of sorting: There are many types of algorithms exist based on the following criteria: Based on Complexity Based on Memory usage (Internal & External

More information

UNIT-2. Problem of size n. Sub-problem 1 size n/2. Sub-problem 2 size n/2. Solution to the original problem

UNIT-2. Problem of size n. Sub-problem 1 size n/2. Sub-problem 2 size n/2. Solution to the original problem Divide-and-conquer method: Divide-and-conquer is probably the best known general algorithm design technique. The principle behind the Divide-and-conquer algorithm design technique is that it is easier

More information

Topics Recursive Sorting Algorithms Divide and Conquer technique An O(NlogN) Sorting Alg. using a Heap making use of the heap properties STL Sorting F

Topics Recursive Sorting Algorithms Divide and Conquer technique An O(NlogN) Sorting Alg. using a Heap making use of the heap properties STL Sorting F CSC212 Data Structure t Lecture 21 Recursive Sorting, Heapsort & STL Quicksort Instructor: George Wolberg Department of Computer Science City College of New York @ George Wolberg, 2016 1 Topics Recursive

More information

Divide-and-Conquer CSE 680

Divide-and-Conquer CSE 680 Divide-and-Conquer CSE 680 1 Introduction Given an instance x of a problem, the divide-and-conquer method works as follows. function DAQ(x) if x is sufficiently small or simple then solve it directly else

More information

Algorithm Analysis. CENG 707 Data Structures and Algorithms

Algorithm Analysis. CENG 707 Data Structures and Algorithms Algorithm Analysis CENG 707 Data Structures and Algorithms 1 Algorithm An algorithm is a set of instructions to be followed to solve a problem. There can be more than one solution (more than one algorithm)

More information

Computer Programming

Computer Programming Computer Programming Dr. Deepak B Phatak Dr. Supratik Chakraborty Department of Computer Science and Engineering Session: Object-oriented Programming using Member Functions Dr. Deepak B. Phatak & Dr. Supratik

More information

Lecture Notes on Quicksort

Lecture Notes on Quicksort Lecture Notes on Quicksort 15-122: Principles of Imperative Computation Frank Pfenning Lecture 8 September 20, 2012 1 Introduction In this lecture we first sketch two related algorithms for sorting that

More information

Algorithm Analysis. Spring Semester 2007 Programming and Data Structure 1

Algorithm Analysis. Spring Semester 2007 Programming and Data Structure 1 Algorithm Analysis Spring Semester 2007 Programming and Data Structure 1 What is an algorithm? A clearly specifiable set of instructions to solve a problem Given a problem decide that the algorithm is

More information

Merge Sort. Algorithm Analysis. November 15, 2017 Hassan Khosravi / Geoffrey Tien 1

Merge Sort. Algorithm Analysis. November 15, 2017 Hassan Khosravi / Geoffrey Tien 1 Merge Sort Algorithm Analysis November 15, 2017 Hassan Khosravi / Geoffrey Tien 1 The story thus far... CPSC 259 topics up to this point Priority queue Abstract data types Stack Queue Dictionary Tools

More information

Sorting. Task Description. Selection Sort. Should we worry about speed?

Sorting. Task Description. Selection Sort. Should we worry about speed? Sorting Should we worry about speed? Task Description We have an array of n values in any order We need to have the array sorted in ascending or descending order of values 2 Selection Sort Select the smallest

More information

Unit #3: Recursion, Induction, and Loop Invariants

Unit #3: Recursion, Induction, and Loop Invariants Unit #3: Recursion, Induction, and Loop Invariants CPSC 221: Basic Algorithms and Data Structures Jan Manuch 2017S1: May June 2017 Unit Outline Thinking Recursively Recursion Examples Analyzing Recursion:

More information

COSC242 Lecture 7 Mergesort and Quicksort

COSC242 Lecture 7 Mergesort and Quicksort COSC242 Lecture 7 Mergesort and Quicksort We saw last time that the time complexity function for Mergesort is T (n) = n + n log n. It is not hard to see that T (n) = O(n log n). After all, n + n log n

More information

Recall from Last Time: Big-Oh Notation

Recall from Last Time: Big-Oh Notation CSE 326 Lecture 3: Analysis of Algorithms Today, we will review: Big-Oh, Little-Oh, Omega (Ω), and Theta (Θ): (Fraternities of functions ) Examples of time and space efficiency analysis Covered in Chapter

More information

Algorithms and Data Structures CS-CO-412

Algorithms and Data Structures CS-CO-412 Algorithms and Data Structures CS-CO-412 David Vernon Professor of Informatics University of Skövde Sweden david@vernon.eu www.vernon.eu Algorithms and Data Structures 1 Copyright D. Vernon 2014 Algorithmic

More information

Lecture 15 : Review DRAFT

Lecture 15 : Review DRAFT CS/Math 240: Introduction to Discrete Mathematics 3/10/2011 Lecture 15 : Review Instructor: Dieter van Melkebeek Scribe: Dalibor Zelený DRAFT Today slectureservesasareviewofthematerialthatwillappearonyoursecondmidtermexam.

More information

The divide-and-conquer paradigm involves three steps at each level of the recursion: Divide the problem into a number of subproblems.

The divide-and-conquer paradigm involves three steps at each level of the recursion: Divide the problem into a number of subproblems. 2.3 Designing algorithms There are many ways to design algorithms. Insertion sort uses an incremental approach: having sorted the subarray A[1 j - 1], we insert the single element A[j] into its proper

More information

Sorting. Sorting. Stable Sorting. In-place Sort. Bubble Sort. Bubble Sort. Selection (Tournament) Heapsort (Smoothsort) Mergesort Quicksort Bogosort

Sorting. Sorting. Stable Sorting. In-place Sort. Bubble Sort. Bubble Sort. Selection (Tournament) Heapsort (Smoothsort) Mergesort Quicksort Bogosort Principles of Imperative Computation V. Adamchik CS 15-1 Lecture Carnegie Mellon University Sorting Sorting Sorting is ordering a list of objects. comparison non-comparison Hoare Knuth Bubble (Shell, Gnome)

More information

CSE373: Data Structure & Algorithms Lecture 21: More Comparison Sorting. Aaron Bauer Winter 2014

CSE373: Data Structure & Algorithms Lecture 21: More Comparison Sorting. Aaron Bauer Winter 2014 CSE373: Data Structure & Algorithms Lecture 21: More Comparison Sorting Aaron Bauer Winter 2014 The main problem, stated carefully For now, assume we have n comparable elements in an array and we want

More information

Test 1 Review Questions with Solutions

Test 1 Review Questions with Solutions CS3510 Design & Analysis of Algorithms Section A Test 1 Review Questions with Solutions Instructor: Richard Peng Test 1 in class, Wednesday, Sep 13, 2017 Main Topics Asymptotic complexity: O, Ω, and Θ.

More information

Merge Sort. Biostatistics 615/815 Lecture 11

Merge Sort. Biostatistics 615/815 Lecture 11 Merge Sort Biostatistics 615/815 Lecture 11 Scheduling I will hand out sample midterm next week Revision Q & A October 26 or November 1? Mid-term Exam November 1 or November 3? Take Home Problem Set 3

More information

Merge Sort. Yufei Tao. Department of Computer Science and Engineering Chinese University of Hong Kong

Merge Sort. Yufei Tao. Department of Computer Science and Engineering Chinese University of Hong Kong Department of Computer Science and Engineering Chinese University of Hong Kong In this lecture, we will design the merge sort which sorts n elements in O(n log n) time. The algorithm illustrates a technique

More information

Computer Science 331

Computer Science 331 Computer Science 331 Merge Sort Wayne Eberly Department of Computer Science University of Calgary Lecture #23 Introduction Merge Sort Merging Conclusions Outline Introduction Merge Sort is is an asymptotically

More information

CSC Design and Analysis of Algorithms

CSC Design and Analysis of Algorithms CSC 8301- Design and Analysis of Algorithms Lecture 6 Divide and Conquer Algorithm Design Technique Divide-and-Conquer The most-well known algorithm design strategy: 1. Divide a problem instance into two

More information

Divide and Conquer. Design and Analysis of Algorithms Andrei Bulatov

Divide and Conquer. Design and Analysis of Algorithms Andrei Bulatov Divide and Conquer Design and Analysis of Algorithms Andrei Bulatov Algorithms Divide and Conquer 4-2 Divide and Conquer, MergeSort Recursive algorithms: Call themselves on subproblem Divide and Conquer

More information

COMP250: Loop invariants

COMP250: Loop invariants COMP250: Loop invariants Jérôme Waldispühl School of Computer Science McGill University Based on (CRLS, 2009) & slides from (Sora,2015) Algorithm specification An algorithm is described by: Input data

More information

Data Structures and Algorithms

Data Structures and Algorithms Data Structures and Algorithms Session 24. Earth Day, 2009 Instructor: Bert Huang http://www.cs.columbia.edu/~bert/courses/3137 Announcements Homework 6 due before last class: May 4th Final Review May

More information

8. Functions (II) Control Structures: Arguments passed by value and by reference int x=5, y=3, z; z = addition ( x, y );

8. Functions (II) Control Structures: Arguments passed by value and by reference int x=5, y=3, z; z = addition ( x, y ); - 50 - Control Structures: 8. Functions (II) Arguments passed by value and by reference. Until now, in all the functions we have seen, the arguments passed to the functions have been passed by value. This

More information

IS 709/809: Computational Methods in IS Research. Algorithm Analysis (Sorting)

IS 709/809: Computational Methods in IS Research. Algorithm Analysis (Sorting) IS 709/809: Computational Methods in IS Research Algorithm Analysis (Sorting) Nirmalya Roy Department of Information Systems University of Maryland Baltimore County www.umbc.edu Sorting Problem Given an

More information

Back to Sorting More efficient sorting algorithms

Back to Sorting More efficient sorting algorithms Back to Sorting More efficient sorting algorithms Merge Sort Strategy break problem into smaller subproblems recursively solve subproblems combine solutions to answer Called divide-and-conquer we used

More information

Lectures 19, 20, 21. two valid iterators in [first, last) such that i precedes j, then *j is not less than *i.

Lectures 19, 20, 21. two valid iterators in [first, last) such that i precedes j, then *j is not less than *i. Lectures 19, 20, 21 1. STL library examples of applications Explanations: The member function pop_back removes the last element of the controlled sequence. The member function pop_front removes the first

More information

Suppose that the following is from a correct C++ program:

Suppose that the following is from a correct C++ program: All multiple choice questions are equally weighted. You can generally assume that code shown in the questions is intended to be syntactically correct, unless something in the question or one of the answers

More information

CS302 Topic: Algorithm Analysis #2. Thursday, Sept. 21, 2006

CS302 Topic: Algorithm Analysis #2. Thursday, Sept. 21, 2006 CS302 Topic: Algorithm Analysis #2 Thursday, Sept. 21, 2006 Analysis of Algorithms The theoretical study of computer program performance and resource usage What s also important (besides performance/resource

More information

Sorting. Sorting in Arrays. SelectionSort. SelectionSort. Binary search works great, but how do we create a sorted array in the first place?

Sorting. Sorting in Arrays. SelectionSort. SelectionSort. Binary search works great, but how do we create a sorted array in the first place? Sorting Binary search works great, but how do we create a sorted array in the first place? Sorting in Arrays Sorting algorithms: Selection sort: O(n 2 ) time Merge sort: O(nlog 2 (n)) time Quicksort: O(n

More information

Cpt S 122 Data Structures. Sorting

Cpt S 122 Data Structures. Sorting Cpt S 122 Data Structures Sorting Nirmalya Roy School of Electrical Engineering and Computer Science Washington State University Sorting Process of re-arranging data in ascending or descending order Given

More information

Data Structures And Algorithms

Data Structures And Algorithms Data Structures And Algorithms Efficient Sorting Algorithms Eng. Anis Nazer First Semester 2017-2018 Efficient Sorting Simple sorting complexity Efficient sorting complexity O(n 2 ) O(nlg n) Merge sort

More information

The divide and conquer strategy has three basic parts. For a given problem of size n,

The divide and conquer strategy has three basic parts. For a given problem of size n, 1 Divide & Conquer One strategy for designing efficient algorithms is the divide and conquer approach, which is also called, more simply, a recursive approach. The analysis of recursive algorithms often

More information

Parallel Sorting Algorithms

Parallel Sorting Algorithms CSC 391/691: GPU Programming Fall 015 Parallel Sorting Algorithms Copyright 015 Samuel S. Cho Sorting Algorithms Review Bubble Sort: O(n ) Insertion Sort: O(n ) Quick Sort: O(n log n) Heap Sort: O(n log

More information

CSE 2123 Sorting. Jeremy Morris

CSE 2123 Sorting. Jeremy Morris CSE 2123 Sorting Jeremy Morris 1 Problem Specification: Sorting Given a list of values, put them in some kind of sorted order Need to know: Which order? Increasing? Decreasing? What does sorted order mean?

More information

COMP Data Structures

COMP Data Structures COMP 2140 - Data Structures Shahin Kamali Topic 5 - Sorting University of Manitoba Based on notes by S. Durocher. COMP 2140 - Data Structures 1 / 55 Overview Review: Insertion Sort Merge Sort Quicksort

More information

MERGESORT. Textbook (pages )

MERGESORT. Textbook (pages ) MERGESORT Textbook (pages 279 294) Merge Algorithm Given: list, an array split into two segments each of which are sorted. The top segment consists of items list[topfirst] to list[toplast]. The bottom

More information

DATA STRUCTURES AND ALGORITHMS

DATA STRUCTURES AND ALGORITHMS DATA STRUCTURES AND ALGORITHMS Fast sorting algorithms Shellsort, Mergesort, Quicksort Summary of the previous lecture Why sorting is needed? Examples from everyday life What are the basic operations in

More information

Lecture 19 Sorting Goodrich, Tamassia

Lecture 19 Sorting Goodrich, Tamassia Lecture 19 Sorting 7 2 9 4 2 4 7 9 7 2 2 7 9 4 4 9 7 7 2 2 9 9 4 4 2004 Goodrich, Tamassia Outline Review 3 simple sorting algorithms: 1. selection Sort (in previous course) 2. insertion Sort (in previous

More information

Data Structures Lecture 3 Order Notation and Recursion

Data Structures Lecture 3 Order Notation and Recursion Data Structures Lecture 3 Order Notation and Recursion 1 Overview The median grade.cpp program from Lecture 2 and background on constructing and using vectors. Algorithm analysis; order notation Recursion

More information

Lecture Notes on Quicksort

Lecture Notes on Quicksort Lecture Notes on Quicksort 15-122: Principles of Imperative Computation Frank Pfenning Lecture 8 February 5, 2015 1 Introduction In this lecture we consider two related algorithms for sorting that achieve

More information

Lecture 5: Sorting Part A

Lecture 5: Sorting Part A Lecture 5: Sorting Part A Heapsort Running time O(n lg n), like merge sort Sorts in place (as insertion sort), only constant number of array elements are stored outside the input array at any time Combines

More information

Chapter 13. Recursion. Copyright 2016 Pearson, Inc. All rights reserved.

Chapter 13. Recursion. Copyright 2016 Pearson, Inc. All rights reserved. Chapter 13 Recursion Copyright 2016 Pearson, Inc. All rights reserved. Learning Objectives Recursive void Functions Tracing recursive calls Infinite recursion, overflows Recursive Functions that Return

More information

Lecture #2. 1 Overview. 2 Worst-Case Analysis vs. Average Case Analysis. 3 Divide-and-Conquer Design Paradigm. 4 Quicksort. 4.

Lecture #2. 1 Overview. 2 Worst-Case Analysis vs. Average Case Analysis. 3 Divide-and-Conquer Design Paradigm. 4 Quicksort. 4. COMPSCI 330: Design and Analysis of Algorithms 8/28/2014 Lecturer: Debmalya Panigrahi Lecture #2 Scribe: Yilun Zhou 1 Overview This lecture presents two sorting algorithms, quicksort and mergesort, that

More information