CO 303 Algorithm Analysis And Design Quicksort 11/23/2018 CO 303 Algorithm Analysis And Design Quicksort Jigar Patel, Lecturer Computer Engg Dept, SVNIT E-mail: p.jigar@coed.svnit.ac.in

11/23/2018

11/23/2018

11/23/2018

Notes on Quicksort Quicksort was invented in 1960 by C. A. R. Hoare. 11/23/2018 Notes on Quicksort Quicksort was invented in 1960 by C. A. R. Hoare. Quicksort is more widely used than any other sort. Quicksort is well-studied, not difficult to implement, works well on a variety of data, and consumes fewer resources that other sorts in nearly all situations. Quicksort is O(n*log n) time, and O(log n) additional space due to recursion.

11/23/2018 Notes on Quicksort Quicksort has withstood the test of time. It has been thoroughly analyzed. The analysis has been verified through extensive empirical experience. Quicksort is not stable. Quicksort performance can degenerate under special circumstances. It is possible modify the algorithm to handle these cases, but at the expense of making the algorithm more complicated. Sedgewick states that “tuning Quicksort is the better mousetrap of computer science.” Many ideas have been tried, but it’s easy to be deceived because the algorithm is so balanced that a perceived improvement in one area can be more than offset by poor performance in another area.

11/23/2018 Quicksort Algorithm Quicksort is a divide-and-conquer method for sorting. It works by partitioning an array into parts, then sorting each part independently. The crux of the problem is how to partition the array such that the following conditions are true: There is some element, a[i], where a[i] is in its final position. For all l < i, a[l] < a[i]. For all i < r, a[i] < a[r].

Quicksort Algorithm (cont) 11/23/2018 Quicksort Algorithm (cont) As is typical with a recursive program, once you figure out how to divide your problem into smaller subproblems, the implementation is amazingly simple. int partition(Item a[], int l, int r); void quicksort(Item a[], int l, int r) { int i; if (r <= l) return; i = partition(a, l, r); quicksort(a, l, i-1); quicksort(a, i+1, r); }

11/23/2018

11/23/2018

Partitioning in Quicksort 11/23/2018 Partitioning in Quicksort How do we partition the array efficiently? choose partition element to be rightmost element scan from left for larger element scan from right for smaller element exchange repeat until pointers cross Q U I C K S O R T L partitioned partition element left right unpartitioned

Partitioning in Quicksort 11/23/2018 Partitioning in Quicksort How do we partition the array efficiently? choose partition element to be rightmost element scan from left for larger element scan from right for smaller element exchange repeat until pointers cross swap me Q U I C K S O R T I S C O O L partitioned partition element left right unpartitioned

Partitioning in Quicksort 11/23/2018 Partitioning in Quicksort How do we partition the array efficiently? choose partition element to be rightmost element scan from left for larger element scan from right for smaller element exchange repeat until pointers cross swap me Q U I C K S O R T I S C O O L partitioned partition element left right unpartitioned

Partitioning in Quicksort 11/23/2018 Partitioning in Quicksort How do we partition the array efficiently? choose partition element to be rightmost element scan from left for larger element scan from right for smaller element exchange repeat until pointers cross swap me Q U I C K S O R T I S C O O L partitioned partition element left right unpartitioned

Partitioning in Quicksort 11/23/2018 Partitioning in Quicksort How do we partition the array efficiently? choose partition element to be rightmost element scan from left for larger element scan from right for smaller element exchange repeat until pointers cross swap me swap me Q U I C K S O R T I S C O O L partitioned partition element left right unpartitioned

Partitioning in Quicksort 11/23/2018 Partitioning in Quicksort How do we partition the array efficiently? choose partition element to be rightmost element scan from left for larger element scan from right for smaller element exchange repeat until pointers cross C U I C K S O R T I S Q O O L partitioned partition element left right unpartitioned

Partitioning in Quicksort 11/23/2018 Partitioning in Quicksort How do we partition the array efficiently? choose partition element to be rightmost element scan from left for larger element scan from right for smaller element exchange repeat until pointers cross swap me C U I C K S O R T I S Q O O L partitioned partition element left right unpartitioned

Partitioning in Quicksort 11/23/2018 Partitioning in Quicksort How do we partition the array efficiently? choose partition element to be rightmost element scan from left for larger element scan from right for smaller element exchange repeat until pointers cross swap me C U I C K S O R T I S Q O O L partitioned partition element left right unpartitioned

Partitioning in Quicksort 11/23/2018 Partitioning in Quicksort How do we partition the array efficiently? choose partition element to be rightmost element scan from left for larger element scan from right for smaller element exchange repeat until pointers cross swap me swap me C U I C K S O R T I S Q O O L partitioned partition element left right unpartitioned

Partitioning in Quicksort 11/23/2018 Partitioning in Quicksort How do we partition the array efficiently? choose partition element to be rightmost element scan from left for larger element scan from right for smaller element exchange repeat until pointers cross C I I C K S O R T U S Q O O L partitioned partition element left right unpartitioned

Partitioning in Quicksort 11/23/2018 Partitioning in Quicksort How do we partition the array efficiently? choose partition element to be rightmost element scan from left for larger element scan from right for smaller element exchange repeat until pointers cross C I I C K S O R T U S Q O O L partitioned partition element left right unpartitioned

Partitioning in Quicksort 11/23/2018 Partitioning in Quicksort How do we partition the array efficiently? choose partition element to be rightmost element scan from left for larger element scan from right for smaller element exchange repeat until pointers cross C I I C K S O R T U S Q O O L partitioned partition element left right unpartitioned

Partitioning in Quicksort 11/23/2018 Partitioning in Quicksort How do we partition the array efficiently? choose partition element to be rightmost element scan from left for larger element scan from right for smaller element exchange repeat until pointers cross C I I C K S O R T U S Q O O L partitioned partition element left right unpartitioned

Partitioning in Quicksort 11/23/2018 Partitioning in Quicksort How do we partition the array efficiently? choose partition element to be rightmost element scan from left for larger element scan from right for smaller element exchange repeat until pointers cross swap me C I I C K S O R T U S Q O O L partitioned partition element left right unpartitioned

Partitioning in Quicksort 11/23/2018 Partitioning in Quicksort How do we partition the array efficiently? choose partition element to be rightmost element scan from left for larger element scan from right for smaller element exchange repeat until pointers cross swap me C I I C K S O R T U S Q O O L partitioned partition element left right unpartitioned

Partitioning in Quicksort 11/23/2018 Partitioning in Quicksort How do we partition the array efficiently? choose partition element to be rightmost element scan from left for larger element scan from right for smaller element exchange repeat until pointers cross swap me C I I C K S O R T U S Q O O L partitioned partition element left right unpartitioned

Partitioning in Quicksort 11/23/2018 Partitioning in Quicksort How do we partition the array efficiently? choose partition element to be rightmost element scan from left for larger element scan from right for smaller element exchange repeat until pointers cross swap me C I I C K S O R T U S Q O O L partitioned partition element left right unpartitioned

Partitioning in Quicksort 11/23/2018 Partitioning in Quicksort How do we partition the array efficiently? choose partition element to be rightmost element scan from left for larger element scan from right for smaller element exchange repeat until pointers cross swap with partitioning element pointers cross C I I C K S O R T U S Q O O L partitioned partition element left right unpartitioned

Partitioning in Quicksort 11/23/2018 Partitioning in Quicksort How do we partition the array efficiently? choose partition element to be rightmost element scan from left for larger element scan from right for smaller element exchange repeat until pointers cross partition is complete C I I C K L O R T U S Q O O S partitioned partition element left right unpartitioned

Partitioning in Quicksort 11/23/2018 Partitioning in Quicksort int partition(Item a[], int l, int r) { int i = l-1, j = r; Item v = a[r]; for (;;) { while (less(a[++i], v)) ; while (less(v, a[--j])) if (j == l) break; if (i >= j) break; exch(a[i], a[j]); } exch(a[i], a[r]); return i;

11/23/2018 Quicksort Demo Quicksort illustrates the operation of the basic algorithm. When the array is partitioned, one element is in place on the diagonal, the left subarray has its upper corner at that element, and the right subarray has its lower corner at that element. The original file is divided into two smaller parts that are sorted independently. The left subarray is always sorted first, so the sorted result emerges as a line of black dots moving right and up the diagonal.

Quicksort Code Quicksort(A, p, r) { if (p < r) q = Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Initial Call is Quicksort(A, 1, length[A])

Partition Clearly, all the action takes place in the partition() function Rearranges the subarray in place End result: Two subarrays All values in first subarray  all values in second Returns the index of the “pivot” element separating the two subarrays How do you suppose we implement this function?

Partition Code Partition(A, p, r) x  A[r] i  p – 1 for j  p to r-1 do if A[j]≤ x then I  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1

Quick Sort A = {2, 8, 7, 1, 3, 5, 6, 4} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 1, 8)

Quick Sort A = {2, 8, 7, 1, 3, 5, 6, 4} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 1, 8) { if(1<8) TRUE

Quick Sort A = {2, 8, 7, 1, 3, 5, 6, 4} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 1, 8) { if(1<8) q  Partition(A,1,8)

Quick Sort A = {2, 8, 7, 1, 3, 5, 6, 4} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 1, 8) { if(1<8) q  Partition(A,1,8) Partition(A,1,8)

Quick Sort A = {2, 8, 7, 1, 3, 5, 6, 4} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 1, 8) { if(1<8) q  Partition(A,1,8) Partition(A,1,8) x = A[8] = 4 i = 1-1 = 0

Quick Sort A = {2, 8, 7, 1, 3, 5, 6, 4} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 1, 8) { if(1<8) q  Partition(A,1,8) Partition(A,1,8) x = A[8] = 4 i = 1-1 = 0 for(j=1;j≤7; j++){

Quick Sort A = {2, 8, 7, 1, 3, 5, 6, 4} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 1, 8) { if(1<8) q  Partition(A,1,8) Partition(A,1,8) x = A[8] = 4 i = 1-1 = 0 for(j=1;j≤7; j++){ if(A[1]≤4 ) => if(2<4) TRUE

Quick Sort A = {2, 8, 7, 1, 3, 5, 6, 4} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 1, 8) { if(1<8) q  Partition(A,1,8) Partition(A,1,8) x = A[8] = 4 i = 1-1 = 0 for(j=1;j≤7; j++){ if(A[1]≤4 ) => if(2<4) TRUE i = 0 + 1 = 1

Quick Sort A = {2, 8, 7, 1, 3, 5, 6, 4} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 1, 8) { if(1<8) q  Partition(A,1,8) Partition(A,1,8) x = A[8] = 4 i = 1-1 = 0 for(j=1;j≤7; j++){ if(A[1]≤4 ) => if(2<4) TRUE i = 0 + 1 = 1 exchange A[1]  A[1]

Quick Sort A = {2, 8, 7, 1, 3, 5, 6, 4} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 1, 8) { if(1<8) q  Partition(A,1,8) Partition(A,1,8) x = A[8] = 4 i = 1-1 = 0 for(j=1;j≤7; j++){ if(A[2]≤4 ) => if(8<4) FALSE

Quick Sort A = {2, 8, 7, 1, 3, 5, 6, 4} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 1, 8) { if(1<8) q  Partition(A,1,8) Partition(A,1,8) x = A[8] = 4 i = 1-1 = 0 for(j=1;j≤7; j++){ if(A[3]≤4 ) => if(7<4) FALSE

Quick Sort A = {2, 8, 7, 1, 3, 5, 6, 4} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 1, 8) { if(1<8) q  Partition(A,1,8) Partition(A,1,8) x = A[8] = 4 i = 1-1 = 0 for(j=1;j≤7; j++){ if(A[4]≤4 ) => if(1<4) TRUE

Quick Sort A = {2, 8, 7, 1, 3, 5, 6, 4} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 1, 8) { if(1<8) q  Partition(A,1,8) Partition(A,1,8) x = A[8] = 4 i = 1-1 = 0 for(j=1;j≤7; j++){ if(A[4]≤4 ) => if(1<4) TRUE i = 1 + 1 = 2

Quick Sort A = {2, 8, 7, 1, 3, 5, 6, 4} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 1, 8) { if(1<8) q  Partition(A,1,8) Partition(A,1,8) x = A[8] = 4 i = 1-1 = 0 for(j=1;j≤7; j++){ if(A[4]≤4 ) => if(1<4) TRUE i = 1 + 1 = 2 exchange A[2]  A[4]

Quick Sort A = {2, 1, 7, 8, 3, 5, 6, 4} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 1, 8) { if(1<8) q  Partition(A,1,8) Partition(A,1,8) x = A[8] = 4 i = 1-1 = 0 for(j=1;j≤7; j++){ if(A[4]≤4 ) => if(1<4) TRUE i = 1 + 1 = 2 exchange A[2]  A[4]

Quick Sort A = {2, 1, 7, 8, 3, 5, 6, 4} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 1, 8) { if(1<8) q  Partition(A,1,8) Partition(A,1,8) x = A[8] = 4 i = 1-1 = 0 for(j=1;j≤7; j++){ if(A[5]≤4 ) => if(3<4) TRUE

Quick Sort A = {2, 1, 7, 8, 3, 5, 6, 4} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 1, 8) { if(1<8) q  Partition(A,1,8) Partition(A,1,8) x = A[8] = 4 i = 1-1 = 0 for(j=1;j≤7; j++){ if(A[5]≤4 ) => if(3<4) TRUE i = 2 + 1 = 3

Quick Sort A = {2, 1, 7, 8, 3, 5, 6, 4} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 1, 8) { if(1<8) q  Partition(A,1,8) Partition(A,1,8) x = A[8] = 4 i = 1-1 = 0 for(j=1;j≤7; j++){ if(A[5]≤4 ) => if(3<4) TRUE i = 2 + 1 = 3 exchange A[3]  A[5]

Quick Sort A = {2, 1, 3, 8, 7, 5, 6, 4} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 1, 8) { if(1<8) q  Partition(A,1,8) Partition(A,1,8) x = A[8] = 4 i = 1-1 = 0 for(j=1;j≤7; j++){ if(A[5]≤4 ) => if(3<4) TRUE i = 2 + 1 = 3 exchange A[3]  A[5]

Quick Sort A = {2, 1, 3, 8, 7, 5, 6, 4} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 1, 8) { if(1<8) q  Partition(A,1,8) Partition(A,1,8) x = A[8] = 4 i = 1-1 = 0 for(j=1;j≤7; j++){ if(A[6]≤4 ) => if(5<4) FALSE

Quick Sort A = {2, 1, 3, 8, 7, 5, 6, 4} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 1, 8) { if(1<8) q  Partition(A,1,8) Partition(A,1,8) x = A[8] = 4 i = 1-1 = 0 for(j=1;j≤7; j++){ if(A[7]≤4 ) => if(6<4) FALSE

Quick Sort A = {2, 1, 3, 8, 7, 5, 6, 4} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 1, 8) { if(1<8) q  Partition(A,1,8) Partition(A,1,8) x = A[8] = 4 i = 1-1 = 0 for(j=1;j≤7; j++){ if(A[7]≤4 ) => if(6<4) FALSE } exchange A[4]  A[8]

Quick Sort A = {2, 1, 3, 4, 7, 5, 6, 8} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 1, 8) { if(1<8) q  Partition(A,1,8) Partition(A,1,8) x = A[8] = 4 i = 1-1 = 0 for(j=1;j≤7; j++){ if(A[7]≤4 ) => if(6<4) FALSE } exchange A[4]  A[8]

Quick Sort A = {2, 1, 3, 4, 7, 5, 6, 8} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 1, 8) { if(1<8) q  Partition(A,1,8) Partition(A,1,8){ x = A[8] = 4 i = 1-1 = 0 for(j=1;j≤7; j++){ if(A[7]≤4 ) => if(6<4) FALSE } exchange A[4]  A[8] return 4

Quick Sort A = {2, 1, 3, 4, 7, 5, 6, 8} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 1, 8) { if(1<8) 4  Partition(A,1,8)

Quick Sort A = {2, 1, 3, 4, 7, 5, 6, 8} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 1, 8) { if(1<8) 4  Partition(A,1,8) Quicksort(A, 1, 3);

Quick Sort A = {2, 1, 3, 4, 7, 5, 6, 8} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 1, 3) {

Quick Sort A = {2, 1, 3, 4, 7, 5, 6, 8} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 1, 3) { if(1<3) TRUE

Quick Sort A = {2, 1, 3, 4, 7, 5, 6, 8} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 1, 3) { if(1<3 q  Partition(A,1,3)

Quick Sort A = {2, 1, 3, 4, 7, 5, 6, 8} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 1, 3) { if(1<3 q  Partition(A,1,3) Partition(A,1,3){

Quick Sort A = {2, 1, 3, 4, 7, 5, 6, 8} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 1, 3) { if(1<3 q  Partition(A,1,3) Partition(A,1,3){ x = A[3] = 3 i = 1-1 = 0

Quick Sort A = {2, 1, 3, 4, 7, 5, 6, 8} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 1, 3) { if(1<3 q  Partition(A,1,3) Partition(A,1,3){ x = A[3] = 3 i = 1-1 = 0 for(j=1;j≤2; j++){

Quick Sort A = {2, 1, 3, 4, 7, 5, 6, 8} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 1, 3) { if(1<3 q  Partition(A,1,3) Partition(A,1,3){ x = A[3] = 3 i = 1-1 = 0 for(j=1;j≤2; j++){ if(A[1]≤3 ) => if(2≤3) TRUE

Quick Sort A = {2, 1, 3, 4, 7, 5, 6, 8} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 1, 3) { if(1<3 q  Partition(A,1,3) Partition(A,1,3){ x = A[3] = 3 i = 1-1 = 0 for(j=1;j≤2; j++){ if(A[1]≤3 ) => if(2≤3) TRUE i = 0 + 1 = 1

Quick Sort A = {2, 1, 3, 4, 7, 5, 6, 8} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 1, 3) { if(1<3 q  Partition(A,1,3) Partition(A,1,3){ x = A[3] = 3 i = 1-1 = 0 for(j=1;j≤2; j++){ if(A[1]≤3 ) => if(2≤3) TRUE i = 0 + 1 = 1 exchange A[1]  A[1]

Quick Sort A = {2, 1, 3, 4, 7, 5, 6, 8} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 1, 3) { if(1<3 q  Partition(A,1,3) Partition(A,1,3){ x = A[3] = 3 i = 1-1 = 0 for(j=1;j≤2; j++){ if(A[2]≤3 ) => if(1≤3) TRUE

Quick Sort A = {2, 1, 3, 4, 7, 5, 6, 8} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 1, 3) { if(1<3 q  Partition(A,1,3) Partition(A,1,3){ x = A[3] = 3 i = 1-1 = 0 for(j=1;j≤2; j++){ if(A[2]≤3 ) => if(1≤3) TRUE i = 1 + 1 = 2

Quick Sort A = {2, 1, 3, 4, 7, 5, 6, 8} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 1, 3) { if(1<3 q  Partition(A,1,3) Partition(A,1,3){ x = A[3] = 3 i = 1-1 = 0 for(j=1;j≤2; j++){ if(A[2]≤3 ) => if(1≤3) TRUE i = 1 + 1 = 2 exchange A[2]  A[2]

Quick Sort A = {2, 1, 3, 4, 7, 5, 6, 8} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 1, 3) { if(1<3 q  Partition(A,1,3) Partition(A,1,3){ x = A[3] = 3 i = 1-1 = 0 for(j=1;j≤2; j++){ if(A[2]≤3 ) => if(1≤3) TRUE i = 1 + 1 = 2 exchange A[2]  A[2] } exchange A[3]  A[3]

Quick Sort A = {2, 1, 3, 4, 7, 5, 6, 8} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 1, 3) { if(1<3 q  Partition(A,1,3) Partition(A,1,3){ x = A[3] = 3 i = 1-1 = 0 for(j=1;j≤2; j++){ if(A[2]≤3 ) => if(1≤3) TRUE i = 1 + 1 = 2 exchange A[2]  A[2] } exchange A[3]  A[3] return 3

Quick Sort A = {2, 1, 3, 4, 7, 5, 6, 8} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 1, 3) { if(1<3 3  Partition(A,1,3)

Quick Sort A = {2, 1, 3, 4, 7, 5, 6, 8} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 1, 3) { if(1<3 3  Partition(A,1,3) Quicksort(A,1,2)

Quick Sort A = {2, 1, 3, 4, 7, 5, 6, 8} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 1, 2) {

Quick Sort A = {2, 1, 3, 4, 7, 5, 6, 8} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 1, 2) { if (1 < 2) TRUE

Quick Sort A = {2, 1, 3, 4, 7, 5, 6, 8} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 1, 2) { if (1 < 2) q  Partition(A, 1, 2);

Quick Sort A = {2, 1, 3, 4, 7, 5, 6, 8} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 1, 2) { if (1 < 2) q  Partition(A, 1, 2); Partition(A,1,2)

Quick Sort A = {2, 1, 3, 4, 7, 5, 6, 8} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 1, 2) { if (1 < 2) q  Partition(A, 1, 2); Partition(A,1,2) x = A[2] = 1 i = 1-1 = 0

Quick Sort A = {2, 1, 3, 4, 7, 5, 6, 8} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 1, 2) { if (1 < 2) q  Partition(A, 1, 2); Partition(A,1,2) x = A[2] = 1 i = 1-1 = 0 for(j=1;j≤1; j++){

Quick Sort A = {2, 1, 3, 4, 7, 5, 6, 8} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 1, 2) { if (1 < 2) q  Partition(A, 1, 2); Partition(A,1,2) x = A[2] = 1 i = 1-1 = 0 for(j=1;j≤1; j++){ if(A[1]≤1 ) => if(2≤1) FALSE }

Quick Sort A = {2, 1, 3, 4, 7, 5, 6, 8} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 1, 2) { if (1 < 2) q  Partition(A, 1, 2); Partition(A,1,2) x = A[2] = 1 i = 1-1 = 0 for(j=1;j≤1; j++){ if(A[1]≤1 ) => if(2≤1) FALSE } exchange A[1]  A[2]

Quick Sort A = {1, 2, 3, 4, 7, 5, 6, 8} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 1, 2) { if (1 < 2) q  Partition(A, 1, 2); Partition(A,1,2) x = A[2] = 1 i = 1-1 = 0 for(j=1;j≤1; j++){ if(A[1]≤1 ) => if(2≤1) FALSE } exchange A[1]  A[2]

Quick Sort A = {1, 2, 3, 4, 7, 5, 6, 8} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 1, 2) { if (1 < 2) q  Partition(A, 1, 2); Partition(A,1,2) x = A[2] = 1 i = 1-1 = 0 for(j=1;j≤1; j++){ if(A[1]≤1 ) => if(2≤1) FALSE } exchange A[1]  A[2] return 1

Quick Sort A = {1, 2, 3, 4, 7, 5, 6, 8} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 1, 2) { if (1 < 2) 1  Partition(A, 1, 2);

Quick Sort A = {1, 2, 3, 4, 7, 5, 6, 8} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 1, 2) { if (1 < 2) 1  Partition(A, 1, 2); Quicksort(A,1,0)

Quick Sort A = {1, 2, 3, 4, 7, 5, 6, 8} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 1, 0) {

Quick Sort A = {1, 2, 3, 4, 7, 5, 6, 8} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 1, 0) { if (1 < 0) FALSE

Quick Sort A = {1, 2, 3, 4, 7, 5, 6, 8} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 1, 2) { if (1 < 2) 1  Partition(A, 1, 2); Quicksort(A,1,0) Quicksort(A,2,2)

Quick Sort A = {1, 2, 3, 4, 7, 5, 6, 8} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 2, 2) {

Quick Sort A = {1, 2, 3, 4, 7, 5, 6, 8} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 2, 2) { if (2 < 2) FALSE

Quick Sort A = {1, 2, 3, 4, 7, 5, 6, 8} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 1, 3) { if(1<3) 3  Partition(A,1,3) Quicksort(A,1,2) Quicksort(A,4,3)

Quick Sort A = {1, 2, 3, 4, 7, 5, 6, 8} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 4, 3) {

Quick Sort A = {1, 2, 3, 4, 7, 5, 6, 8} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 4, 3) { if (4 < 3) FALSE

Quick Sort A = {1, 2, 3, 4, 7, 5, 6, 8} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 1, 8) { if(1<8) 4  Partition(A,1,8) Quicksort(A, 1, 3); Quicksort(A, 5, 8);

Quick Sort A = {1, 2, 3, 4, 7, 5, 6, 8} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 5, 8) {

Quick Sort A = {1, 2, 3, 4, 7, 5, 6, 8} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 5, 8) { if (5 < 8) TRUE

Quick Sort A = {1, 2, 3, 4, 7, 5, 6, 8} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 5, 8) { if(5 < 8) q  Partition(A,1,3);

Quick Sort A = {1, 2, 3, 4, 7, 5, 6, 8} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 5, 8) { if(5 < 8) q  Partition(A,5,8); Partition(A, 5, 8) x = A[8] = 8 i = 5-1 = 4

Quick Sort A = {1, 2, 3, 4, 7, 5, 6, 8} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 5, 8) { if(5 < 8) q  Partition(A,5,8); Partition(A, 5, 8) x = A[8] = 8 i = 5-1 = 4 for(j=5;j≤7; j++){

Quick Sort A = {1, 2, 3, 4, 7, 5, 6, 8} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 5, 8) { if(5 < 8) q  Partition(A,5,8); Partition(A, 5, 8) x = A[8] = 8 i = 5-1 = 4 for(j=5;j≤7; j++){ if(A[5]≤8 ) => if(7≤8) TRUE

Quick Sort A = {1, 2, 3, 4, 7, 5, 6, 8} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 5, 8) { if(5 < 8) q  Partition(A,5,8); Partition(A, 5, 8) x = A[8] = 8 i = 5-1 = 4 for(j=5;j≤7; j++){ if(A[5]≤8 ) => if(7≤8) TRUE i = 4 + 1 = 5

Quick Sort A = {1, 2, 3, 4, 7, 5, 6, 8} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 5, 8) { if(5 < 8) q  Partition(A,5,8); Partition(A, 5, 8) x = A[8] = 8 i = 5-1 = 4 for(j=5;j≤7; j++){ if(A[5]≤8 ) => if(7≤8) TRUE i = 4 + 1 = 5 exchange A[5]  A[5]

Quick Sort A = {1, 2, 3, 4, 7, 5, 6, 8} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 5, 8) { if(5 < 8) q  Partition(A,5,8); Partition(A, 5, 8) x = A[8] = 8 i = 5-1 = 4 for(j=5;j≤7; j++){ if(A[6]≤8 ) => if(5≤8) TRUE

Quick Sort A = {1, 2, 3, 4, 7, 5, 6, 8} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 5, 8) { if(5 < 8) q  Partition(A,5,8); Partition(A, 5, 8) x = A[8] = 8 i = 5-1 = 4 for(j=5;j≤7; j++){ if(A[6]≤8 ) => if(5≤8) TRUE i = 5 + 1 = 6

Quick Sort A = {1, 2, 3, 4, 7, 5, 6, 8} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 5, 8) { if(5 < 8) q  Partition(A,5,8); Partition(A, 5, 8) x = A[8] = 8 i = 5-1 = 4 for(j=5;j≤7; j++){ if(A[6]≤8 ) => if(5≤8) TRUE i = 5 + 1 = 6 exchange A[6]  A[6]

Quick Sort A = {1, 2, 3, 4, 7, 5, 6, 8} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 5, 8) { if(5 < 8) q  Partition(A,5,8); Partition(A, 5, 8) x = A[8] = 8 i = 5-1 = 4 for(j=5;j≤7; j++){ if(A[7]≤8 ) => if(6≤8) TRUE

Quick Sort A = {1, 2, 3, 4, 7, 5, 6, 8} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 5, 8) { if(5 < 8) q  Partition(A,5,8); Partition(A, 5, 8) x = A[8] = 8 i = 5-1 = 4 for(j=5;j≤7; j++){ if(A[7]≤8 ) => if(6≤8) TRUE i = 6 + 1 = 7

Quick Sort A = {1, 2, 3, 4, 7, 5, 6, 8} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 5, 8) { if(5 < 8) q  Partition(A,5,8); Partition(A, 5, 8) x = A[8] = 8 i = 5-1 = 4 for(j=5;j≤7; j++){ if(A[7]≤8 ) => if(6≤8) TRUE i = 6 + 1 = 7 exchange A[7]  A[7]

Quick Sort A = {1, 2, 3, 4, 7, 5, 6, 8} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 5, 8) { if(5 < 8) q  Partition(A,5,8); Partition(A, 5, 8) x = A[8] = 8 i = 5-1 = 4 for(j=5;j≤7; j++){ if(A[7]≤8 ) => if(6≤8) TRUE i = 6 + 1 = 7 exchange A[7]  A[7] } exchange A[8]  A[8]

Quick Sort A = {1, 2, 3, 4, 7, 5, 6, 8} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 5, 8) { if(5 < 8) q  Partition(A,5,8); Partition(A, 5, 8) x = A[8] = 8 i = 5-1 = 4 for(j=5;j≤7; j++){ if(A[7]≤8 ) => if(6≤8) TRUE i = 6 + 1 = 7 exchange A[7]  A[7] } exchange A[8]  A[8] return 8

Quick Sort A = {1, 2, 3, 4, 7, 5, 6, 8} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 5, 8) { if(5 < 8) 8  Partition(A,5,8);

Quick Sort A = {1, 2, 3, 4, 7, 5, 6, 8} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 5, 8) { if(5 < 8) 8  Partition(A,5,8); Quicksort(A,5,7)

Quick Sort A = {1, 2, 3, 4, 7, 5, 6, 8} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 5, 7) {

Quick Sort A = {1, 2, 3, 4, 7, 5, 6, 8} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 5, 7) { if(5 < 7) TRUE

Quick Sort A = {1, 2, 3, 4, 7, 5, 6, 8} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 5, 7) { if(5 < 7) q  Partition(A,5,7);

Quick Sort A = {1, 2, 3, 4, 7, 5, 6, 8} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 5, 7) { if(5 < 7) q  Partition(A,5,7); Partition(A, 5, 7)

Quick Sort A = {1, 2, 3, 4, 7, 5, 6, 8} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 5, 7) { if(5 < 7) q  Partition(A,5,7); Partition(A, 5, 7) x = A[7] = 6 i = 5-1 = 4

Quick Sort A = {1, 2, 3, 4, 7, 5, 6, 8} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 5, 7) { if(5 < 7) q  Partition(A,5,7); Partition(A, 5, 7) x = A[7] = 6 i = 5-1 = 4 for(j=5;j≤6; j++){

Quick Sort A = {1, 2, 3, 4, 7, 5, 6, 8} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 5, 7) { if(5 < 7) q  Partition(A,5,7); Partition(A, 5, 7) x = A[7] = 6 i = 5-1 = 4 for(j=5;j≤6; j++){ if(A[5]≤6 ) => if(7≤6) FALSE

Quick Sort A = {1, 2, 3, 4, 7, 5, 6, 8} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 5, 7) { if(5 < 7) q  Partition(A,5,7); Partition(A, 5, 7) x = A[7] = 6 i = 5-1 = 4 for(j=5;j≤6; j++){ if(A[6]≤5 ) => if(5≤6) TRUE

Quick Sort A = {1, 2, 3, 4, 7, 5, 6, 8} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 5, 7) { if(5 < 7) q  Partition(A,5,7); Partition(A, 5, 7) x = A[7] = 6 i = 5-1 = 4 for(j=5;j≤6; j++){ if(A[6]≤5 ) => if(5≤6) TRUE i = 4 + 1 =5

Quick Sort A = {1, 2, 3, 4, 7, 5, 6, 8} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 5, 7) { if(5 < 7) q  Partition(A,5,7); Partition(A, 5, 7) x = A[7] = 6 i = 5-1 = 4 for(j=5;j≤6; j++){ if(A[6]≤5 ) => if(5≤6) TRUE i = 4 + 1 = 5 exchange A[5]  A[6]

Quick Sort A = {1, 2, 3, 4, 5, 7, 6, 8} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 5, 7) { if(5 < 7) q  Partition(A,5,7); Partition(A, 5, 7) x = A[7] = 6 i = 5-1 = 4 for(j=5;j≤6; j++){ if(A[6]≤5 ) => if(5≤6) TRUE i = 4 + 1 = 5 exchange A[5]  A[6]

Quick Sort A = {1, 2, 3, 4, 5, 7, 6, 8} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 5, 7) { if(5 < 7) q  Partition(A,5,7); Partition(A, 5, 7) x = A[7] = 6 i = 5-1 = 4 for(j=5;j≤6; j++){ if(A[6]≤5 ) => if(5≤6) TRUE i = 4 + 1 = 5 exchange A[5]  A[6] } exchange A[6]  A[7]

Quick Sort A = {1, 2, 3, 4, 5, 6, 7, 8} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 5, 7) { if(5 < 7) q  Partition(A,5,7); Partition(A, 5, 7) x = A[7] = 6 i = 5-1 = 4 for(j=5;j≤6; j++){ if(A[6]≤5 ) => if(5≤6) TRUE i = 4 + 1 = 5 exchange A[5]  A[6] } exchange A[6]  A[7]

Quick Sort A = {1, 2, 3, 4, 5, 6, 7, 8} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 5, 7) { if(5 < 7) q  Partition(A,5,7); Partition(A, 5, 7) x = A[7] = 6 i = 5-1 = 4 for(j=5;j≤6; j++){ if(A[6]≤5 ) => if(5≤6) TRUE i = 4 + 1 = 5 exchange A[5]  A[6] } exchange A[6]  A[7] return 6

Quick Sort A = {1, 2, 3, 4, 5, 6, 7, 8} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 5, 7) { if(5 < 7) 6  Partition(A,5,7);

Quick Sort A = {1, 2, 3, 4, 5, 6, 7, 8} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 5, 7) { if(5 < 7) 6  Partition(A,5,7); Quicksort(A, 5, 5);

Quick Sort A = {1, 2, 3, 4, 5, 6, 7, 8} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 5, 5) {

Quick Sort A = {1, 2, 3, 4, 5, 6, 7, 8} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 5, 5) { if(5 < 5) FALSE

Quick Sort A = {1, 2, 3, 4, 5, 6, 7, 8} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 5, 7) { if(5 < 7) 6  Partition(A,5,7); Quicksort(A, 5, 5); Quicksort(A, 7, 7);

Quick Sort A = {1, 2, 3, 4, 5, 6, 7, 8} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 7, 7) {

Quick Sort A = {1, 2, 3, 4, 5, 6, 7, 8} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 7, 7) { if(7 < 7) FALSE

Quick Sort A = {1, 2, 3, 4, 5, 6, 7, 8} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 5, 8) { if(5 < 8) 8  Partition(A,5,8); Quicksort(A,5,7) Quicksort(A,9,8)

Quick Sort A = {1, 2, 3, 4, 5, 6, 7, 8} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 9, 8) {

Quick Sort A = {1, 2, 3, 4, 5, 6, 7, 8} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 9, 8) { if(9 < 8) FALSE

Quick Sort A = {1, 2, 3, 4, 5, 6, 7, 8} Quicksort(A, p, r) { if (p < r) q  Partition(A, p, r); Quicksort(A, p, q-1); Quicksort(A, q+1, r); } Partition(A, p, r) x  A[r] i  p - 1 for j  p to r-1 do if A[j]≤ x then i  i+ 1 exchange A[i]  A[j] exchange A[i+1]  A[r] return i+1 Quicksort (A, 5, 8) { if(5 < 8) 8  Partition(A,5,8); Quicksort(A,5,7) Quicksort(A,9,8) }

Analyzing Quicksort What will be the worst case for the algorithm? Partition is always unbalanced What will be the best case for the algorithm? Partition is perfectly balanced Which is more likely? The latter, by far Will any particular input elicit the worst case? Yes: Already-sorted input

Analyzing Quicksort (Worst Case) In the worst case: The worst case occurs when the partitioning produces one subproblem with n − 1 elements and another one with 0 element. T(1) = (1) T(n) = T(n - 1) + (n) Works out to T(n) = (n2)

Analyzing Quicksort (Worst Case) Hence, if the partitioning is maximally unbalanced at every recursive level of the algorithm We end up with the same running time as that of the insertion sort. This indeed will occur when the list is either completely sorted, or reversely sorted.

Analyzing Quicksort (Best Case) If the partitioning always produces two balanced subproblems Each of which is no more than n/2, The quisksort will be much faster The associated recurrence will be T(n) = 2T(n/2) + (n) What does this work out to? T(n) = (n lg n)

Analyzing Quicksort: Average Case Assuming random input, average-case running time is much closer to O(n lg n) than O(n2) First, a more intuitive explanation/example: Suppose that partition() always produces a 9-to-1 split. This looks quite unbalanced! The recurrence is thus: T(n) = T(9n/10) + T(n/10) What does this work out to? T(n) = (n lg n)

What does it look like?

A little conclusion We now know that this unbalanced partitioning can be partitioned at most log n times, each of which is involved with at most cn comparisons. Hence, the total cost of the quicksort, even in this unbalanced partitioning, is also O(n log n). In general, whenever a constant proportion is cut at all the partitioning, the quicksort always runs at O(n log n).

Improving Quicksort The real liability of quicksort is that it runs in O(n2) on already-sorted input Book discusses two solutions: Randomize the input array, OR Pick a random pivot element

A randomized version In analyzing the average case, we will assume that all permutations of the input numbers are equally likely. This is usually not true in practice. We can add a randomization piece to the algorithm to obtain a good average-case performance on all the possible inputs. As a result, a randomized version of the quicksort algorithm has become the sorting algorithm of choice for large number of elements

What should be the pivot? We always use the last element as the pivot, which is not always ideal It could be either the smallest or the biggest one We could apply the technique of random sampling Instead of using A[r], we randomly choose an element, Switch it with A[r], and then Apply the original algorithm. We now expect the split of the list will be a balanced one

The Code RANDOMIZED-QUICKSORT(A, p, r) if p<r then q<-RANDOMIZED-PARTITION(A, p, r) RANDOMIZED-QUICKSORT(A, p, q-1) RANDOMIZED-QUICKSORT(A, q+1, r) RANDOMIZED-PARTITION(A, p, r) i<-RANDOM(p, r) exchange(A[i], A[r]) return PARTITION(A, p, r)

Comparison