Presentation is loading. Please wait.

Presentation is loading. Please wait.

CO 303 Algorithm Analysis And Design Quicksort

Published byJerome Manning Modified over 5 years ago

Similar presentations

Presentation on theme: "CO 303 Algorithm Analysis And Design Quicksort"— Presentation transcript:

1 CO 303 Algorithm Analysis And Design Quicksort
11/23/2018 CO 303 Algorithm Analysis And Design Quicksort Jigar Patel, Lecturer Computer Engg Dept, SVNIT

2 11/23/2018

3 11/23/2018

4 11/23/2018

5 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.

6 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.

7 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].

8 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); }

9 11/23/2018

10 11/23/2018

11 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

12 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

13 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

14 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

15 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

16 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

17 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

18 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

19 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

20 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

21 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

22 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

23 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

24 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

25 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

26 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

27 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

28 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

29 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

30 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;

31 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.

32 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])

33 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?

34 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

35 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)

36 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

37 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)

38 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)

39 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

40 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++){

41 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

42 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 = = 1

43 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 = = 1 exchange A[1]  A[1]

44 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

45 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

46 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

47 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 = = 2

48 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 = = 2 exchange A[2]  A[4]

49 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 = = 2 exchange A[2]  A[4]

50 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

51 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 = = 3

52 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 = = 3 exchange A[3]  A[5]

53 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 = = 3 exchange A[3]  A[5]

54 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

55 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

56 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]

57 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]

58 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

59 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)

60 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);

61 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) {

62 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

63 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)

64 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){

65 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

66 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++){

67 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

68 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 = = 1

69 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 = = 1 exchange A[1]  A[1]

70 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

71 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 = = 2

72 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 = = 2 exchange A[2]  A[2]

73 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 = = 2 exchange A[2]  A[2] } exchange A[3]  A[3]

74 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 = = 2 exchange A[2]  A[2] } exchange A[3]  A[3] return 3

75 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)

76 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)

77 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) {

78 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

79 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);

80 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)

81 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

82 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++){

83 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 }

84 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]

85 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]

86 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

87 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);

88 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)

89 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) {

90 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

91 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)

92 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) {

93 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

94 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)

95 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) {

96 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

97 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);

98 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) {

99 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

100 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);

101 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

102 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++){

103 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

104 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 = = 5

105 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 = = 5 exchange A[5]  A[5]

106 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

107 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 = = 6

108 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 = = 6 exchange A[6]  A[6]

109 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

110 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 = = 7

111 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 = = 7 exchange A[7]  A[7]

112 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 = = 7 exchange A[7]  A[7] } exchange A[8]  A[8]

113 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 = = 7 exchange A[7]  A[7] } exchange A[8]  A[8] return 8

114 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);

115 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)

116 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) {

117 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

118 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);

119 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)

120 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

121 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++){

122 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

123 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

124 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 = =5

125 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 = = 5 exchange A[5]  A[6]

126 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 = = 5 exchange A[5]  A[6]

127 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 = = 5 exchange A[5]  A[6] } exchange A[6]  A[7]

128 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 = = 5 exchange A[5]  A[6] } exchange A[6]  A[7]

129 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 = = 5 exchange A[5]  A[6] } exchange A[6]  A[7] return 6

130 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);

131 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);

132 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) {

133 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

134 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);

135 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) {

136 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

137 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)

138 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) {

139 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

140 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) }

141 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

142 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)

143 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.

144 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)

145 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)

146 What does it look like?

147 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).

148 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

149 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

150 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

151 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)

152 Comparison

Download ppt "CO 303 Algorithm Analysis And Design Quicksort"

Similar presentations

David Luebke 1 4/22/2015 CS 332: Algorithms Quicksort.

David Luebke 1 4/22/2015 CS 332: Algorithms Quicksort.
Algorithms Analysis Lecture 6 Quicksort. Quick Sort 88 14 98 25 62 52 79 30 23 31 Divide and Conquer.

Algorithms Analysis Lecture 6 Quicksort. Quick Sort Divide and Conquer.
242-535 ADA: 5. Quicksort1 Objective o describe the quicksort algorithm, it's partition function, and analyse its running time under different data conditions.

ADA: 5. Quicksort1 Objective o describe the quicksort algorithm, it's partition function, and analyse its running time under different data conditions.
CS4413 Divide-and-Conquer

CS4413 Divide-and-Conquer
Quicksort CSE 331 Section 2 James Daly. Review: Merge Sort Basic idea: split the list into two parts, sort both parts, then merge the two lists 11324262152728.

Quicksort CSE 331 Section 2 James Daly. Review: Merge Sort Basic idea: split the list into two parts, sort both parts, then merge the two lists
Spring 2015 Lecture 5: QuickSort & Selection

Spring 2015 Lecture 5: QuickSort & Selection
25 May 20151 Quick Sort (11.2) CSE 2011 Winter 2011.

25 May Quick Sort (11.2) CSE 2011 Winter 2011.
Introduction to Algorithms Chapter 7: Quick Sort.

Introduction to Algorithms Chapter 7: Quick Sort.
Updated 29.3.2004. QuickSort Problem From a given set of n integers, find the missing integer from 0 to n using O(n) queries of type: “what is bit[j]

Updated QuickSort Problem From a given set of n integers, find the missing integer from 0 to n using O(n) queries of type: “what is bit[j]
Quicksort Many of the slides are from Prof. Plaisted’s resources at University of North Carolina at Chapel Hill.

Quicksort Many of the slides are from Prof. Plaisted’s resources at University of North Carolina at Chapel Hill.
Quick Sort. Quicksort Quicksort is a well-known sorting algorithm developed by C. A. R. Hoare. The quick sort is an in-place, divide- and-conquer, massively.

Quick Sort. Quicksort Quicksort is a well-known sorting algorithm developed by C. A. R. Hoare. The quick sort is an in-place, divide- and-conquer, massively.
Quicksort CIS 606 Spring 2010. Quicksort Worst-case running time: Θ(n 2 ). Expected running time: Θ(n lg n). Constants hidden in Θ(n lg n) are small.

Quicksort CIS 606 Spring Quicksort Worst-case running time: Θ(n 2 ). Expected running time: Θ(n lg n). Constants hidden in Θ(n lg n) are small.
Chapter 7 (Part 2) Sorting Algorithms Merge Sort.

Chapter 7 (Part 2) Sorting Algorithms Merge Sort.
Computer Algorithms Lecture 10 Quicksort Ch. 7 Some of these slides are courtesy of D. Plaisted et al, UNC and M. Nicolescu, UNR.

Computer Algorithms Lecture 10 Quicksort Ch. 7 Some of these slides are courtesy of D. Plaisted et al, UNC and M. Nicolescu, UNR.
Chapter 7 Quicksort Ack: This presentation is based on the lecture slides from Hsu, Lih- Hsing, as well as various materials from the web.

Chapter 7 Quicksort Ack: This presentation is based on the lecture slides from Hsu, Lih- Hsing, as well as various materials from the web.
David Luebke 1 6/3/2016 CS 332: Algorithms Analyzing Quicksort: Average Case.

David Luebke 1 6/3/2016 CS 332: Algorithms Analyzing Quicksort: Average Case.
Quicksort CSE 2320 – Algorithms and Data Structures Vassilis Athitsos University of Texas at Arlington 1.

Quicksort CSE 2320 – Algorithms and Data Structures Vassilis Athitsos University of Texas at Arlington 1.
Quicksort This is probably the most popular sorting algorithm. It was invented by the English Scientist C.A.R. Hoare It is popular because it works well.

Quicksort This is probably the most popular sorting algorithm. It was invented by the English Scientist C.A.R. Hoare It is popular because it works well.
QuickSort. Yet another sorting algorithm! Usually faster than other algorithms on average, although worst-case is O(n 2 ) Divide-and-conquer: –Divide:

QuickSort. Yet another sorting algorithm! Usually faster than other algorithms on average, although worst-case is O(n 2 ) Divide-and-conquer: –Divide:
Partitioning in Quicksort n How do we partition the array efficiently? – choose partition element to be rightmost element – scan from right for smaller.

Partitioning in Quicksort n How do we partition the array efficiently? – choose partition element to be rightmost element – scan from right for smaller.

Similar presentations

Ads by Google