1.		    -----------------------------------------
		    |  7 | 39 | 20 | 11 | 16 |  5 |  9 | 28 |
		    -----------------------------------------
				      split
				/               \
		---------------------       ---------------------
		|  7 | 39 | 20 | 11 |       | 16 |  5 |  9 | 28 |
		---------------------       ---------------------
		      split                           split
		  /           \                   /           \
	  -----------     -----------       -----------     -----------
	  |  7 | 39 |     | 20 | 11 |       | 16 |  5 |     |  9 | 28 |
	  -----------     -----------       -----------     -----------
	split               split               split               split
      /       \           /       \           /       \           /       \
   ------   ------     ------   ------     ------   ------     ------   ------
   |  7 |   | 39 |     | 20 |   | 11 |     | 16 |   |  5 |     |  9 |   | 28 |
   ------   ------     ------   ------     ------   ------     ------   ------
      \       /           \       /           \       /           \       /
	merge               merge               merge               merge
     -----------         -----------         -----------         -----------
     |  7 | 39 |         | 11 | 20 |         |  5 | 16 |         |  9 | 28 |
     -----------         -----------         -----------         -----------
	       \         /                             \         /
		  merge                                   merge  
	  ---------------------                   ---------------------
	  |  7 | 11 | 20 | 39 |                   |  5 |  9 | 16 | 28 |
	  ---------------------                   ---------------------
		    \                                       /
		    -----------------------------------------
		    |  5 |  7 |  9 | 11 | 16 | 20 | 28 | 39 |
		    -----------------------------------------


2.  Unlike quicksort, merge sort *always* divides the current subarray
    evenly in half, and so its call tree is more or less perfectly
    balanced, with the number of levels of the tree being proportional
    to log to the base 2 of n, were n is the length of the array.
    Therefore, merge sort gives O(n log n) performance even in the 
    worst case, whereas quicksort can degenerate into O(n^2)
    performance if its partitions are consistently skewed and the
    number of levels in the call tree approaches n.


3.  Merge sort requires O(n) additional memory to sort an array of
    length n, whereas quicksort uses only O(1) additional memory.