Quicksort可视化？

Question

I'm fairly new to programming and would like some visual representation of the quicksort algorithm using median-of-three partitioning and a cutoff of 3.

I would like to see the entire iterative process because the Java algorithm is tough to understand for me.

For example, try applying quicksort to this array: [2, 6, 3, 1, 6, 5, 2, 4, 8]

With the median-of-three rule, the pivot is the median of the leftmost, center, and rightmost elements. So the median of 2, 6, and 8 is 6. What now?

Answer 1

The next step is partitioning: when you have selected a pivot, move all elements smaller than the pivot to the left and all elements larger to the right. Once this is done, you can separately sort on the left and on the right.

Before partitioning:

[2,6,3,1,6,5,2,4,8]

After partitioning <6 on the left, >=6 on the right:

[2,3,1,5,2,4] [6,6,8]

To sort left and right, repeat the same procedure on both sides.

I let you discover the very details of the partitioning procedure (the true one leaves the elements in a different order).

Issues to remember:

• after partitioning, there must remain at least one element in either side, otherwise the procedure can loop forever (at worse, the only element left can be the pivot);

• ideally, the partitioning splits the array in two subarrays of roughly equal size; but very unequal sizes can also arise, making the algorithm much slower; the median-of-three heuristic does not fully avoid that phenomenon;

• the algorithm is written in a recursive way (the sorting function calls itself). When sorting the two subarrays, begin with the smallest so that the number of nested calls is minimized. This is important;

• the procedure is overkill for small arrays, this is why it is advisable to switch to a simpler method, like StraightInsertion or StraightSelection in this case.

You can sketch the whole sorting process as a binary tree where a node holds an array, with the pivot distinguished, and has two sons holding the subarrays.

Answer 2

So the medium of 2,6,8 is 6. What now?

The next step is to partition the array into the left half, containing elements that are less than 6, and the right half, containing elements that are equal to or greater than 6. Then we call quicksort on each half.

The following Java program implements quicksort, displaying each subarray before and after sorting. It also displays the choice of median.

import java.io.*;

public class Quicksort {
  void swap(int[] data, int i, int j) {
    int t = data[i];
    data[i] = data[j];
    data[j] = t;
  }

  void display(int[] data, int left, int right) {
    for (int i = 0; i < right; ++i) {
      System.out.print(i < left ? "  " : " "+data[i]);
    }
    System.out.println();
  }

  //--- in-place implementation with median-of-three pivot
  int quicksort(int[] data, int left, int right, int callId) {
    int saveCallId = callId;
    System.out.print(callId+". sorting:");
    display(data, left, right);
    if (left+1 >= right) {
      System.out.print("  "+saveCallId+". result:");
      display(data, left, right);
      return callId;
    }
    int ai = left, bi = (left+right)/2, ci = right-1, pos;
    int a = data[ai], b = data[bi], c = data[ci];
    if (a < b) {
      if (c < a) {
        pos = ai;
      } else if (c < b) {
        pos = ci;
      } else {
        pos = bi;
      }
    } else {
      if (c < b) {
        pos = bi;
      } else if (c < a) {
        pos = ci;
      } else {
        pos = ai;
      }
    }
    int pivot = data[pos];
    System.out.println("   median of ["+a+", "+b+", "+c+"] is "+pivot);
    swap(data, right-1, pos);
    int tail = left;
    for (int i = left; i != right-1; ++i) {
      if (data[i] < pivot) {
        swap(data, tail, i);
        ++tail;
      }
    }
    swap(data, right-1, tail);
    callId = quicksort(data, left, tail, ++callId);
    callId = quicksort(data, tail+1, right, ++callId);
    System.out.print("  "+saveCallId+". result:");
    display(data, left, right);
    return callId;
  }

  public static void main(String[] args) {
    int[] data = new int[]{ 2, 6, 3, 1, 6, 5, 2, 4, 8 };
    new Quicksort().quicksort(data, 0, data.length, 0);
  }
}

For the input case { 2, 6, 3, 1, 6, 5, 2, 4, 8 } , the output is:

0. sorting: 2 6 3 1 6 5 2 4 8
   median of [2, 6, 8] is 6
1. sorting: 2 3 1 5 2 4
   median of [2, 5, 4] is 4
2. sorting: 2 3 1 2
   median of [2, 1, 2] is 2
3. sorting: 1
  3. result: 1
4. sorting:     2 3
   median of [2, 3, 3] is 3
5. sorting:     2
  5. result:     2
6. sorting:        
  6. result:        
  4. result:     2 3
  2. result: 1 2 2 3
7. sorting:           5
  7. result:           5
  1. result: 1 2 2 3 4 5
8. sorting:               6 8
   median of [6, 8, 8] is 8
9. sorting:               6
  9. result:               6
10. sorting:                  
  10. result:                  
  8. result:               6 8
  0. result: 1 2 2 3 4 5 6 6 8

Answer 3

You can see an interactive visualization and play with it at the walnut . It uses the Dijkstra partitioning (smaller, equal, larger than the pivot).