Quicksort

• This sort was developed in 1959 by Tony Hoare
• This is a divide and conquer algorithm (combine step is missing)
• The idea
  • Pick a "pivot" value
  • Move all data smaller than that pivot to the lower half of the array
  • Move all data larger than that pivot to the upper half of the array.
  • 
  • Sort the two halves.
• The Algorithm

  Quicksort(A, low, high) 
  // low is the index of the first item to be sorted.
  // high is the index of the last item to be sorted.
  
      pivot = Partition(A, low, high)
      Quicksort(A, low, partition-1)
      Quicksort(A, partition, high) 
   

  • Depending on the partition algorithm, this might change slightly
• There are several pivot algorithms
  • The Hoare partition scheme
    • Pick an element to serve as the partition.
    • From the current starting point find the first element larger than the partition.
    • From the current ending point, find the first element smaller than the partition.
    • Swap these.
    • Repeat until the two positions pass.
    • Wherever they meet is the partition point.
  • 

  • int Partition(A, low, high)
    
     pivot = A[(low+high/2)]
     lowpos = low-1
     highpos = high+1
     While lowPos < highPos
          Repeat
             lowPos++
          Until A[lowPos] >= pivot
          Repeat
             highPos--
          Until A[highPos] <= pivot
          If LowPos < HighPos
             swap(A[lowPos], A[highPos])
          Endif
     EndWhile
     return highPos 
     

  • Try partitioning the following

    • Index	0	1	2	3	4	5	6	7	8	9	10
      PrePart	4	12	6	15	4	9	6	27	8	24	5
      PostPart

    • Index	0	1	2	3	4	5	6	7	8	9	10
      PrePart	1	4	5	8	10	11	3	7	2	9	6
      PostPart
• The big three?
  • Does this work?
  • What is the performance?
    • Assume the partition splits in the middle (the first case above)
    • Assume the partition doesn't split in the middle.
      • How bad can this be?
• There are other partitioning algorithms, but as far as I can tell, this is the current "best".
• Look at QuickSort.h