The Quicksort algorithm is one of the best examples of the power of recursion.  Students often find Quicksort difficult to understand at first.  This is probably due to the concision of recursion.  By observing the visualisation of Quicksort at work presented by this applet students should be able to more readily understand it’s

The main graphics window displays a representation of an unsorted array and as the Quicksort algorithm partitions the array into sub sections the animation shows how these subsections are further divided until the end goal of a sorted array is achieved.

  1. In area A the Java source code for the recursive sorting algorithm Quicksort
    is displayed.  As the algorithm executes the current line of execution
    is highlighted. 
  2. This animation shows pictorially how Quicksort sorts an array of integers
    by partitioning the array into smaller and smaller chunks until the array
    have been partitions into sub-partitions not more than one element long. 
  3. This is the the levels of recursion.  This bar graph shows the current
    level of recursion, (i.e. the number of recursive calls on the stack) 
  4. Gives a textual explanation of  the line currently under execution
    in A.  Use the speed control bar (E) to slow down the algorithm so
    that you can read each message and follow the "code walk through" at your
    own pace.
  5. This speed control allows you to speed up and slow down the rate at which
    the algorithm executes.