Sorting Lesson Outline

Slides:

Advertisements

Similar presentations

Recursion Chapter 14. Overview Base case and general case of recursion. A recursion is a method that calls itself. That simplifies the problem. The simpler.

Advertisements

SEARCHING AND SORTING HINT AT ASYMPTOTIC COMPLEXITY Lecture 9 CS2110 – Spring 2015 We may not cover all this material.

Searching and Sorting Algorithms Based on D. S

Sorting Algorithms and Average Case Time Complexity

Data Structures and Algorithms PLSD210 Sorting. Card players all know how to sort … First card is already sorted With all the rest, ¶Scan back from the.

CS 1704 Introduction to Data Structures and Software Engineering.

1 Sorting/Searching CS308 Data Structures. 2 Sorting means... l Sorting rearranges the elements into either ascending or descending order within the array.

General Computer Science for Engineers CISC 106 James Atlas Computer and Information Sciences 10/23/2009.

C++ Plus Data Structures

Cmpt-225 Sorting. Fundamental problem in computing science  putting a collection of items in order Often used as part of another algorithm  e.g. sort.

User Defined Functions Lesson 2 CS1313 Spring User Defined Functions 2 Outline 1.User Defined Functions 2 Outline 2.Argument Order When Passing.

Search Lesson CS1313 Spring Search Lesson Outline 1.Searching Lesson Outline 2.How to Find a Value in an Array? 3.Linear Search 4.Linear Search.

For Loop Lesson 3 CS1313 Spring for Loop Lesson 3 Outline 1. for Loop Lesson 3 Outline 2. for Loop with a float Counter: BAD! 3. float Counter Example.

Characters & Strings Lesson 2 CS1313 Spring Characters & Strings Lesson 2 Outline 1.Characters & Strings Lesson 2 Outline 2.Character String Declaration.

1 Data Structures and Algorithms Sorting. 2  Sorting is the process of arranging a list of items into a particular order  There must be some value on.

Array Lesson 1 CS1313 Spring Array Lesson 1 Outline 1.Array Lesson 1 Outline 2.Mean of a List of Numbers 3.mean: Declarations 4.mean: Greeting,

Array Lesson 2 CS1313 Spring Array Lesson 2 Outline 1.Array Lesson 2 Outline 2.Reading Array Values Using for Loop #1 3.Reading Array Values Using.

C++ Programming: From Problem Analysis to Program Design, Second Edition Chapter 19: Searching and Sorting.

LAB#7. Insertion sort In the outer for loop, out starts at 1 and moves right. It marks the leftmost unsorted data. In the inner while loop, in starts.

Chapter 5 Searching and Sorting. Copyright © 2004 Pearson Addison-Wesley. All rights reserved.1-2 Chapter Objectives Examine the linear search and binary.

1 C++ Plus Data Structures Nell Dale Chapter 10 Sorting and Searching Algorithms Slides by Sylvia Sorkin, Community College of Baltimore County - Essex.

Sorting. Sorting Terminology Sort Key –each element to be sorted must be associated with a sort key which can be compared with other keys e.g. for any.

Sorting CS Sorting means... Sorting rearranges the elements into either ascending or descending order within the array. (we’ll use ascending order.)

Review 1 Selection Sort Selection Sort Algorithm Time Complexity Best case Average case Worst case Examples.

1 Searching and Sorting Searching algorithms with simple arrays Sorting algorithms with simple arrays –Selection Sort –Insertion Sort –Bubble Sort –Quick.

User Defined Functions Lesson 1 CS1313 Spring User Defined Functions 1 Outline 1.User Defined Functions 1 Outline 2.Standard Library Not Enough.

Chapter 9 Sorting. The efficiency of data handling can often be increased if the data are sorted according to some criteria of order. The first step is.

Sorting Lesson CS1313 Spring Sorting Lesson Outline 1.Sorting Lesson Outline 2.How to Sort an Array? 3.Many Sorting Algorithms 4.Bubble Sort #1.

1 CS 132 Spring 2008 Chapter 10 Sorting Algorithms.

16 Searching and Sorting.

Sorting Mr. Jacobs.

Recitation 13 Searching and Sorting.

Search Lesson Outline Searching Lesson Outline

CS 162 Intro to Programming II

Sorting Algorithms CENG 213 Data Structures 1.

Alg2_1c Extra Material for Alg2_1

Teach A level Computing: Algorithms and Data Structures

Data Structures and Algorithms

Advance Analysis of Algorithms

How can this be simplified?

10.3 Bubble Sort Chapter 10 - Sorting.

Searching and Sorting Linear Search Binary Search ; Reading p

Sorting means The values stored in an array have keys of a type for which the relational operators are defined. (We also assume unique keys.) Sorting.

Merge Sort Merge sort is a recursive algorithm for sorting that decomposes the large problem.

Bubble Sort Bubble sort is one way to sort an array of numbers. Adjacent values are swapped until the array is completely sorted. This algorithm gets its.

Array Lesson 1 Outline Array Lesson 1 Array Lesson 1 Outline

Algorithm design and Analysis

Sorting Algorithms IT12112 Lecture 07.

Selection Sort – an array sorting algorithm

Quicksort analysis Bubble sort

User Defined Functions 2 Outline

Build Heap and Heap Sort

Arrays Outline Introduction Arrays Declaring Arrays

MSIS 655 Advanced Business Applications Programming

Nested if Lesson Outline

for Loop Lesson 3 Outline

C++ Plus Data Structures

24 Searching and Sorting.

Sub-Quadratic Sorting Algorithms

CSE 373 Data Structures and Algorithms

Data Structures & Algorithms

Chapter 10 Sorting Algorithms

Searching/Sorting/Searching

Searching and Sorting Hint at Asymptotic Complexity

Workshop for CS-AP Teachers

Searching and Sorting Hint at Asymptotic Complexity

Searching and Sorting Hint at Asymptotic Complexity

Presentation transcript:

Sorting Lesson Outline How to Sort an Array? Many Sorting Algorithms Bubble Sort #1 Bubble Sort #2 Bubble Sort #3 Bubble Sort #4 Bubble Sort #5 Bubble Sort Run Start Bubble Sort Run Iteration #1 Bubble Sort Run Iteration #2 Bubble Sort Run Iteration #3 Bubble Sort Run Iteration #4 Bubble Sort Run Iteration #5 Bubble Sort Run Iteration #6 Bubble Sort Run Iteration #7 Bubble Sort Run Iteration #8 Bubble Sort Run End Time Complexity of Bubble Sort #1 Time Complexity of Bubble Sort #2 Selection Sort Selection Sort #1 Selection Sort #2 Selection Sort Run Start Selection Sort Run Minimum #1 Selection Sort Run Minimum #2 Selection Sort Run Minimum #3 Selection Sort Run Minimum #4 Selection Sort Run Minimum #5 Selection Sort Run Minimum #6 Selection Sort Run Minimum #7 Selection Sort Run Minimum #8 Selection Sort Run End Time Complexity of Selection Sort #1 Time Complexity of Selection Sort #2 Quick Sort #1 Quick Sort #2 Quick Sort #3 Quick Sort #4 Quick Sort #5 Quick Sort Run Start Quick Sort Run Call: low 0, high 8 Quick Sort Run Call: low 0, high 3 Quick Sort Run Call: low 2, high 3 Quick Sort Run Call: low 0, high 3 End Quick Sort Run Call: low 5, high 8 Quick Sort Run Call: low 5, high 6 Quick Sort Run Call: low 7, high 8 Quick Sort Run Call: low 5, high 8 End Quick Sort Run Call: low 0, high 8 End Quick Sort Run End Time Complexity of Quick Sort #1 Time Complexity of Quick Sort #2 Sorting Lesson CS1313 Spring 2017

How to Sort an Array? Suppose you have a big array full of data, and you want to put it into order, either from lowest to highest (ascending) or highest to lowest (descending). How can you sort it so that it’s in the order you want? -23 97 18 21 5 -86 64 -37 Sorting Lesson CS1313 Spring 2017

Many Sorting Algorithms Bubble Sort Selection Sort Quick Sort … and many more. Sorting Lesson CS1313 Spring 2017

Bubble Sort #1 http://en.wikipedia.org/wiki/Bubble_sort #include <stdio.h> int main () { /* main */ const int minimum_length = 1; const int first_element = 0; const int program_failure_code = -1; const int program_success_code = 0; int* array = (int*)NULL; int length, element; void bubble_sort(int* array, int length); void print_array(int* array, int length); http://en.wikipedia.org/wiki/Bubble_sort Sorting Lesson CS1313 Spring 2017

Bubble Sort #2 printf("I'm going to sort an array for you.\n"); printf("How many elements will the array have?\n"); scanf("%d", &length); if (length < minimum_length) { printf("ERROR: can't have an array of length %d.\n", length); exit(program_failure_code); } /* if (length < minimum_length) */ array = (int*)malloc(sizeof(int) * length); if (array == (int*)NULL) { printf("ERROR: can't allocate an array of length %d.\n", } /* if (array == (int*)NULL) */ printf("What are the %d elements, unsorted?\n", length); for (element = first_element; element < length; element++) { scanf("%d", &array[element]); } /* for element */ bubble_sort(array, length); printf("The %d elements, sorted, are:\n", length); print_array(array, length); return program_success_code; } /* main */ Sorting Lesson CS1313 Spring 2017

Bubble Sort #3 void bubble_sort (int* array, int length) const int first_element = 0; const int first_iteration = 0; const char false = 0; const char true = 1; int temporary; int element; int iteration; char this_iteration_had_a_swap; /* Boolean */ void print_array(int* array, int length); Sorting Lesson CS1313 Spring 2017

Bubble Sort #4 iteration = first_iteration; this_iteration_had_a_swap = true; while (this_iteration_had_a_swap) { printf("\n"); this_iteration_had_a_swap = false; for (element = first_element; element < (length - 1); element++) { if (array[element] > array[element + 1]) { /* Swap! */ temporary = array[element]; array[element] = array[element + 1]; array[element + 1] = temporary; } /* if (array[ element ] > array[ element + 1 ]) */ printf("After iteration #%d", iteration); printf(" comparing elements #%d/%d:\n", element, element + 1); print_array(array, length); } /* for element */ iteration++; } /* while (this_iteration_had_a_swap) */ } /* bubble_sort */ Sorting Lesson CS1313 Spring 2017

Bubble Sort #5 void print_array (int* array, int length) const int first_element = 0; int element; for (element = first_element; element < length; element++) { printf("%d ", array[element]); } /* for element */ printf("\n"); } /* print_array */ Sorting Lesson CS1313 Spring 2017

Bubble Sort Run Start % bubblesort I'm going to sort an array for you. How many elements will the array have? 9 What are the 9 elements, unsorted? -23 97 18 21 5 -86 64 0 -37 Sorting Lesson CS1313 Spring 2017

Bubble Sort Run Iteration #1 After iteration #1 comparing elements #0/1: -23 97 18 21 5 -86 64 0 -37 After iteration #1 comparing elements #1/2: -23 18 97 21 5 -86 64 0 -37 After iteration #1 comparing elements #2/3: -23 18 21 97 5 -86 64 0 -37 After iteration #1 comparing elements #3/4: -23 18 21 5 97 -86 64 0 -37 After iteration #1 comparing elements #4/5: -23 18 21 5 -86 97 64 0 -37 After iteration #1 comparing elements #5/6: -23 18 21 5 -86 64 97 0 -37 After iteration #1 comparing elements #6/7: -23 18 21 5 -86 64 0 97 -37 After iteration #1 comparing elements #7/8: -23 18 21 5 -86 64 0 -37 97 Sorting Lesson CS1313 Spring 2017

Bubble Sort Run Iteration #2 After iteration #2 comparing elements #0/1: -23 18 21 5 -86 64 0 -37 97 After iteration #2 comparing elements #1/2: After iteration #2 comparing elements #2/3: -23 18 5 21 -86 64 0 -37 97 After iteration #2 comparing elements #3/4: -23 18 5 -86 21 64 0 -37 97 After iteration #2 comparing elements #4/5: After iteration #2 comparing elements #5/6: -23 18 5 -86 21 0 64 -37 97 After iteration #2 comparing elements #6/7: -23 18 5 -86 21 0 -37 64 97 After iteration #2 comparing elements #7/8: Sorting Lesson CS1313 Spring 2017

Bubble Sort Run Iteration #3 After iteration #3 comparing elements #0/1: -23 18 5 -86 21 0 -37 64 97 After iteration #3 comparing elements #1/2: -23 5 18 -86 21 0 -37 64 97 After iteration #3 comparing elements #2/3: -23 5 -86 18 21 0 -37 64 97 After iteration #3 comparing elements #3/4: After iteration #3 comparing elements #4/5: -23 5 -86 18 0 21 -37 64 97 After iteration #3 comparing elements #5/6: -23 5 -86 18 0 -37 21 64 97 After iteration #3 comparing elements #6/7: After iteration #3 comparing elements #7/8: Sorting Lesson CS1313 Spring 2017

Bubble Sort Run Iteration #4 After iteration #4 comparing elements #0/1: -23 5 -86 18 0 -37 21 64 97 After iteration #4 comparing elements #1/2: -23 -86 5 18 0 -37 21 64 97 After iteration #4 comparing elements #2/3: After iteration #4 comparing elements #3/4: -23 -86 5 0 18 -37 21 64 97 After iteration #4 comparing elements #4/5: -23 -86 5 0 -37 18 21 64 97 After iteration #4 comparing elements #5/6: After iteration #4 comparing elements #6/7: After iteration #4 comparing elements #7/8: Sorting Lesson CS1313 Spring 2017

Bubble Sort Run Iteration #5 After iteration #5 comparing elements #0/1: -86 -23 5 0 -37 18 21 64 97 After iteration #5 comparing elements #1/2: After iteration #5 comparing elements #2/3: -86 -23 0 5 -37 18 21 64 97 After iteration #5 comparing elements #3/4: -86 -23 0 -37 5 18 21 64 97 After iteration #5 comparing elements #4/5: After iteration #5 comparing elements #5/6: After iteration #5 comparing elements #6/7: After iteration #5 comparing elements #7/8: Sorting Lesson CS1313 Spring 2017

Bubble Sort Run Iteration #6 After iteration #6 comparing elements #0/1: -86 -23 0 -37 5 18 21 64 97 After iteration #6 comparing elements #1/2: After iteration #6 comparing elements #2/3: -86 -23 -37 0 5 18 21 64 97 After iteration #6 comparing elements #3/4: After iteration #6 comparing elements #4/5: After iteration #6 comparing elements #5/6: After iteration #6 comparing elements #6/7: After iteration #6 comparing elements #7/8: Sorting Lesson CS1313 Spring 2017

Bubble Sort Run Iteration #7 After iteration #7 comparing elements #0/1: -86 -23 -37 0 5 18 21 64 97 After iteration #7 comparing elements #1/2: -86 -37 -23 0 5 18 21 64 97 After iteration #7 comparing elements #2/3: After iteration #7 comparing elements #3/4: After iteration #7 comparing elements #4/5: After iteration #7 comparing elements #5/6: After iteration #7 comparing elements #6/7: After iteration #7 comparing elements #7/8: Sorting Lesson CS1313 Spring 2017

Bubble Sort Run Iteration #8 After iteration #8 comparing elements #0/1: -86 -37 -23 0 5 18 21 64 97 After iteration #8 comparing elements #1/2: After iteration #8 comparing elements #2/3: After iteration #8 comparing elements #3/4: After iteration #8 comparing elements #4/5: After iteration #8 comparing elements #5/6: After iteration #8 comparing elements #6/7: After iteration #8 comparing elements #7/8: Sorting Lesson CS1313 Spring 2017

Bubble Sort Run End The 9 elements, sorted, are: -86 -37 -23 0 5 18 21 64 97 Sorting Lesson CS1313 Spring 2017

Time Complexity of Bubble Sort #1 iteration = first_iteration; this_iteration_had_a_swap = true; while (this_iteration_had_a_swap) { printf("\n"); this_iteration_had_a_swap = false; for (element = first_element; element < (length - 1); element++) { if (array[element] > array[element + 1]) { /* Swap! */ temporary = array[element]; array[element] = array[element + 1]; array[element + 1] = temporary; } /* if (array[ element ] > array[ element + 1 ]) */ printf("After iteration #%d", iteration); printf(" comparing elements #%d/%d:\n", element, element + 1); print_array(array, length); } /* for element */ iteration++; } /* while (this_iteration_had_a_swap) */ } /* bubble_sort */ Sorting Lesson CS1313 Spring 2017

Time Complexity of Bubble Sort #2 What is the time complexity of bubble sort? Suppose the array has length n. Well, the inner for loop always has n-1 iterations. How many iterations does the outer while loop have? Well, the outer loop will iterate until the whole array is sorted (plus one extra iteration to determine that it is sorted). On average, it’ll have to do that about ½ n times. Therefore, the time complexity is O(n2) – which is bad. Sorting Lesson CS1313 Spring 2017

Selection Sort Selection sort works by selecting the lowest (or highest) value in the list and swapping it with the first (or last) element, then finding the second lowest (or highest) and swapping it with the second (or next-to-last) element, and so on. http://en.wikipedia.org/wiki/Selection_sort Sorting Lesson CS1313 Spring 2017

Selection Sort #1 Sorting Lesson void selection_sort (int* array, int length) { /* selection_sort */ const int first_element = 0; int temporary; int element1, element2, minimum_element; void print_array(int* array, int length); Sorting Lesson CS1313 Spring 2017

Selection Sort #2 Sorting Lesson for (element1 = first_element; element1 < (length - 1); element1++) { /* Find the minimum. */ minimum_element = element1; for (element2 = element1 + 1; element2 < length; element2++) { if (array[element2] < array[minimum_element]) { minimum_element = element2; } /* if (array[element2] < array[minimum_element]) */ printf("Element %d is %d, minimum element at %d is %d.\n", element2, array[element2], minimum_element, array[minimum_element]); } /* for element2 */ /* Swap! */ temporary = array[element1]; array[element1] = array[minimum_element]; array[minimum_element] = temporary; printf("Minimum #%d had index %d", element1 + 1, minimum_element); printf(" but now has index %d:\n", element1); print_array(array, length); } /* for element1 */ } /* selection_sort */ Sorting Lesson CS1313 Spring 2017

Selection Sort Run Start I'm going to sort an array for you. How many elements will the array have? 9 What are the 9 elements, unsorted? -23 97 18 21 5 -86 64 0 -37 Sorting Lesson CS1313 Spring 2017

Selection Sort Run Minimum #1 -23 97 18 21 5 -86 64 0 -37 Element 1 is 97, minimum element at 0 is -23. Element 2 is 18, minimum element at 0 is -23. Element 3 is 21, minimum element at 0 is -23. Element 4 is 5, minimum element at 0 is -23. Element 5 is -86, minimum element at 5 is -86. Element 6 is 64, minimum element at 5 is -86. Element 7 is 0, minimum element at 5 is -86. Element 8 is -37, minimum element at 5 is -86. Minimum #1 had index 5 but now has index 0: -86 97 18 21 5 -23 64 0 -37 Sorting Lesson CS1313 Spring 2017

Selection Sort Run Minimum #2 -86 97 18 21 5 -23 64 0 -37 Element 2 is 18, minimum element at 2 is 18. Element 3 is 21, minimum element at 2 is 18. Element 4 is 5, minimum element at 4 is 5. Element 5 is -23, minimum element at 5 is -23. Element 6 is 64, minimum element at 5 is -23. Element 7 is 0, minimum element at 5 is -23. Element 8 is -37, minimum element at 8 is -37. Minimum #2 had index 8 but now has index 1: -86 -37 18 21 5 -23 64 0 97 Sorting Lesson CS1313 Spring 2017

Selection Sort Run Minimum #3 -86 -37 18 21 5 -23 64 0 97 Element 3 is 21, minimum element at 2 is 18. Element 4 is 5, minimum element at 4 is 5. Element 5 is -23, minimum element at 5 is -23. Element 6 is 64, minimum element at 5 is -23. Element 7 is 0, minimum element at 5 is -23. Element 8 is 97, minimum element at 5 is -23. Minimum #3 had index 5 but now has index 2: -86 -37 -23 21 5 18 64 0 97 Sorting Lesson CS1313 Spring 2017

Selection Sort Run Minimum #4 -86 -37 -23 21 5 18 64 0 97 Element 4 is 5, minimum element at 4 is 5. Element 5 is 18, minimum element at 4 is 5. Element 6 is 64, minimum element at 4 is 5. Element 7 is 0, minimum element at 7 is 0. Element 8 is 97, minimum element at 7 is 0. Minimum #4 had index 7 but now has index 3: -86 -37 -23 0 5 18 64 21 97 Sorting Lesson CS1313 Spring 2017

Selection Sort Run Minimum #5 -86 -37 -23 0 5 18 64 21 97 Element 5 is 18, minimum element at 4 is 5. Element 6 is 64, minimum element at 4 is 5. Element 7 is 21, minimum element at 4 is 5. Element 8 is 97, minimum element at 4 is 5. Minimum #5 had index 4 but now has index 4: Sorting Lesson CS1313 Spring 2017

Selection Sort Run Minimum #6 -86 -37 -23 0 5 18 64 21 97 Element 6 is 64, minimum element at 5 is 18. Element 7 is 21, minimum element at 5 is 18. Element 8 is 97, minimum element at 5 is 18. Minimum #6 had index 5 but now has index 5: Sorting Lesson CS1313 Spring 2017

Selection Sort Run Minimum #7 -86 -37 -23 0 5 18 64 21 97 Element 7 is 21, minimum element at 7 is 21. Element 8 is 97, minimum element at 7 is 21. Minimum #7 had index 7 but now has index 6: -86 -37 -23 0 5 18 21 64 97 Sorting Lesson CS1313 Spring 2017

Selection Sort Run Minimum #8 -86 -37 -23 0 5 18 21 64 97 Element 8 is 97, minimum element at 7 is 64. Minimum #8 had index 7 but now has index 7: Sorting Lesson CS1313 Spring 2017

Selection Sort Run End The 9 elements, sorted, are: -86 -37 -23 0 5 18 21 64 97 Sorting Lesson CS1313 Spring 2017

Time Complexity of Selection Sort #1 for (element1 = first_element; element1 < (length - 1); element1++) { /* Find the minimum. */ minimum_element = element1; for (element2 = element1 + 1; element2 < length; element2++) { if (array[element2] < array[minimum_element]) { minimum_element = element2; } /* if (array[element2] < array[minimum_element]) */ } /* for element2 */ /* Swap! */ temporary = array[element1]; array[element1] = array[minimum_element]; array[minimum_element] = temporary; printf("Minimum #%d had index %d", element1, minimum_element); printf(" but now has index %d:\n", element1); print_array(array, length); } /* for element1 */ } /* selection_sort */ Sorting Lesson CS1313 Spring 2017

Time Complexity of Selection Sort #2 What is the time complexity of selection sort? Suppose the array has length n. Well, the outer for loop always has n-1 iterations. How many iterations does the inner for loop have? Well, for the first iteration of the outer loop, the inner loop has n-1 iterations; for the second iteration of the outer loop, the inner loop has n-2 iterations; and so on. On average, the inner loop will have approximately ½ n iterations. Therefore, the time complexity is O(n2) – which is bad. Sorting Lesson CS1313 Spring 2017

Quick Sort #1 Sorting Lesson void quicksort (int* array, int length) void quicksort_helper(int* array, int length, int low, int high); quicksort_helper(array, length, 0, length - 1); } /* quicksort */ http://www.inf.fh-flensburg.de/lang/algorithmen/sortieren/quick/quicken.htm Sorting Lesson CS1313 Spring 2017

Quick Sort #2 void quicksort_helper (int* array, int length, int low, int high) { /* quicksort_helper */ int temporary; int element1, element2, middle; int pivot; void print_array(int* array, int length); element1 = low; element2 = high; middle = (low + high) / 2; pivot = array[middle]; Sorting Lesson CS1313 Spring 2017

Quick Sort #3 /* Partition this part of the array into halves. */ do { while (array[element1] < pivot) { element1++; printf("low %d, high %d, pivot %d, element1 %d\n", low, high, pivot, element1); print_array(array, length); } /* while (array[element1] < pivot) */ while (array[element2] > pivot) { element2--; printf("low %d, high %d, pivot %d, element2 %d\n", low, high, pivot, element2); } /* while (array[element2] > pivot) */ Sorting Lesson CS1313 Spring 2017

Quick Sort #4 /* Now, all values at indices between element1 * and element2 are in the wrong place. */ if (element1 <= element2) { /* Swap! */ temporary = array[element1]; array[element1] = array[element2]; array[element2] = temporary; element1++; element2--; printf("low %d, high %d, pivot %d,", low, high, pivot); printf(" element1 %d, element2 %d:\n", element1, element2); print_array(array, length); } /* if (element1 <= element2) */ } while (element1 <= element2); Sorting Lesson CS1313 Spring 2017

Quick Sort #5 /* Recursively sort the two halves. */ if (low < element2) { quicksort_helper(array, length, low, element2); } /* if (low < element2) */ if (element1 < high) { quicksort_helper(array, length, element1, high); } /* if (element1 < high) */ printf("After sorting, %d through %d is:\n", low, high); print_array(array, length); } /* quicksort_helper */ Sorting Lesson CS1313 Spring 2017

Quick Sort Run Start I'm going to sort an array for you. How many elements will the array have? 9 What are the 9 elements, unsorted? -23 97 18 21 5 -86 64 0 -37 Sorting Lesson CS1313 Spring 2017

Quick Sort Run Call: low 0, high 8 -23 97 18 21 5 -86 64 0 -37 low 0, high 8, pivot 5, element1 1 low 0, high 8, pivot 5, element1 2, element2 7: -23 -37 18 21 5 -86 64 0 97 low 0, high 8, pivot 5, element1 3, element2 6: -23 -37 0 21 5 -86 64 18 97 low 0, high 8, pivot 5, element2 5 low 0, high 8, pivot 5, element1 4, element2 4: -23 -37 0 -86 5 21 64 18 97 low 0, high 8, pivot 5, element1 5, element2 3: Sorting Lesson CS1313 Spring 2017

Quick Sort Run Call: low 0, high 3 -23 -37 0 -86 5 21 64 18 97 low 0, high 3, pivot -37, element1 1, element2 2: -86 -37 0 -23 5 21 64 18 97 low 0, high 3, pivot -37, element2 1 low 0, high 3, pivot -37, element1 2, element2 0: Sorting Lesson CS1313 Spring 2017

Quick Sort Run Call: low 2, high 3 -86 -37 0 -23 5 21 64 18 97 low 2, high 3, pivot 0, element1 3, element2 2: -86 -37 -23 0 5 21 64 18 97 After sorting, 2 through 3 is: Sorting Lesson CS1313 Spring 2017

Quick Sort Run Call: low 0, high 3 End After sorting, 0 through 3 is: -86 -37 -23 0 5 21 64 18 97 Sorting Lesson CS1313 Spring 2017

Quick Sort Run Call: low 5, high 8 -86 -37 -23 0 5 21 64 18 97 low 5, high 8, pivot 64, element1 6 low 5, high 8, pivot 64, element2 7 low 5, high 8, pivot 64, element1 7, element2 6: -86 -37 -23 0 5 21 18 64 97 Sorting Lesson CS1313 Spring 2017

Quick Sort Run Call: low 5, high 6 -86 -37 -23 0 5 21 18 64 97 low 5, high 6, pivot 21, element1 6, element2 5: -86 -37 -23 0 5 18 21 64 97 After sorting, 5 through 6 is: Sorting Lesson CS1313 Spring 2017

Quick Sort Run Call: low 7, high 8 -86 -37 -23 0 5 18 21 64 97 low 7, high 8, pivot 64, element2 7 low 7, high 8, pivot 64, element1 8, element2 6: After sorting, 7 through 8 is: Sorting Lesson CS1313 Spring 2017

Quick Sort Run Call: low 5, high 8 End After sorting, 5 through 8 is: -86 -37 -23 0 5 18 21 64 97 Sorting Lesson CS1313 Spring 2017

Quick Sort Run Call: low 0, high 8 End After sorting, 0 through 8 is: -86 -37 -23 0 5 18 21 64 97 Sorting Lesson CS1313 Spring 2017

Quick Sort Run End The 9 elements, sorted, are: -86 -37 -23 0 5 18 21 64 97 Sorting Lesson CS1313 Spring 2017

Time Complexity of Quick Sort #1 What is the time complexity of quick sort? Suppose the array has length n. Well, each call to quicksort_helper cuts the array in half. But, each call to quicksort_helper can be accompanied by another call that covers the other half of the current subarray. So, at each level of calls, most of the array gets visited. So all we need to know is, how many levels of calls are there? Sorting Lesson CS1313 Spring 2017

Time Complexity of Quick Sort #2 At each level of calls, the entire array gets visited. All we need to know is, how many levels of calls are there? It turns out that, for an array of length n, there are O(log n) levels. So the total time complexity is O(n log n) – it’s quick! Sorting Lesson CS1313 Spring 2017