The sequence we want to sort is:
```
3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5
```
3, 9, and 5 are the three values selected as potential pivot candidates. 3 and 5 are the left and rightmost elements in the array and 9 is the center element:
```
       a[center] = a[(left + right)/2] = a[(0 + 10)/2] = a[5] = 9
       
```
3 and 9 are the first two values compared because they are the left and center values. They are in the proper order so we proceed to the next step, where the left and right values are compared, which are 3 and 5. Again the values are in the correct order. The final test for determining the pivot is to compare the current center and right values, which are 9 and 5. Since 5 is less than 9, 5 and 9 swap positions:
```
       
     3, 1, 4, 1, 5, 5, 2, 6, 5, 3, 9
       
```
Next we place the pivot aside by swapping it with the next to last element in the array, which is 3:
```
       
     3, 1, 4, 1, 5, 3, 2, 6, 5, 5, 9
       
```
The leftmost and rightmost elements, 3 and 9 respectively, are now in the correct partition and 5 has been set aside until the end. Hence we set our left index to 1 and our right index to the first element to the left of our pivot. Our initial configuration is then: -----> 3, 1, 4, 1, 5, 3, 2, 6, 5, 5, 9 ^ ^ left right left moves right until it encounters 5, which is equal to the pivot, and hence belongs in the right partition. right stops immediately because it also points to a 5. This 5 belongs in the left partition: -----> 3, 1, 4, 1, 5, 3, 2, 6, 5, 5, 9 ^ ^ left right Now we swap the two 5's and update our indices by moving left one position to the right and right one position to the left: -----> 3, 1, 4, 1, 5, 3, 2, 6, 5, 5, 9 ^ ^ left right left moves rightward until it encounters 6, which is greater than the pivot and thus belongs in the right partition. right moves leftward until it encounters 2, which is less than the pivot and thus belongs in the left partition. -----> 3, 1, 4, 1, 5, 3, 2, 6, 5, 5, 9 ^ ^ right left Since the left and right indices have crossed over all the array elements are now in the correct partition except for the pivot. Note that we do not have to exchange the elements pointed to by left and right because they are already in the correct partition. Our last step is to swap the pivot with the element pointed at by left, which is 6. By doing so we place the pivot in the correct location in the final sorted array: -----> 3, 1, 4, 1, 5, 3, 2, 5, 5, 6, 9 ^ ^ right left This action completes the first partition phase. Note that one 5 appears in the left partition and one 5 appears in the right partition. This is ok because eventually the partitioning process will move the two 5's towards one another until they rest next to the pivot, which is also 5.
The left partition starts at 0 and ends at 6 and the right partition starts at 8 and ends at 10. Note that the left partition ends immediately before the left pointer and the right partition starts immediately after the left pointer. That is because the left pointer points to the pivot element, which belongs to neither partition.

Insertion Sort:

Initial configuration	3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5
Step 1: swap 1 & 3	1, 3, 4, 1, 5, 9, 2, 6, 5, 3, 5
Step 2: 4 is in the right place	1, 3, 4, 1, 5, 9, 2, 6, 5, 3, 5
Step 3: insert 1 after the first 1	1, 1, 3, 4, 5, 9, 2, 6, 5, 3, 5
Step 4: 5 is in the right place	1, 1, 3, 4, 5, 9, 2, 6, 5, 3, 5
Step 5: 9 is in the right place	1, 1, 3, 4, 5, 9, 2, 6, 5, 3, 5
Final configuration after 5 steps	1, 1, 3, 4, 5, 9, 2, 6, 5, 3, 5

In the following solutions I use the pipe character, |, to separate runs and I use the "$$" string to rexmpsent a sentinel value. I've used an asterisk, *, to indicate elements in the priority queue that belong in the next run:

In an array with all duplicate values every element is equal to the pivot and hence every pair of elements pointed to by left and right will get swapped. Since every pair of elements gets swapped, the left and right partitions will have the same number of elements. Since the partitioning algorithm will then be applied to these two equal-sized partitions, the recurrence relation will be: The initial N term represents the work required to partition the array into two halves. Each element of the array is examined, and hence there is O(N) work required to partition the array. The term T(N/2) represents the time quicksort requires to sort an array of size N/2 and since quicksort will be called recursively on the left and right partitions, we multiply T(N/2) by 2. The solution to this recurrence is N log N and hence the running time of the quicksort algorithm using median-of-three partitioning on an array of duplicate keys is O(N log N).
You know that the final structure of the array is going to have all the false values in the left side of the array, all of the true values in the right side of the array, and all of the maybe values in the middle of the array. An efficient algorithm can take advantage of this information by keeping two indices that point to the two ends of the array and swapping false or true values to either the left or right end of the array when one of those two values is encountered. The maybe values will end up getting shepharded towards the middle of the array. The pseudo-code for this algorithm follows:
- quicksort: unstable because duplicate keys can be swapped if they are equal to the pivot. This swapping changes the original order of the duplicate keys.
- insertion sort: stable because duplicate elements are always inserted after duplicate elements that have already been encountered.
- selection sort: stable because the first duplicate element found is always the one moved to the beginning of the array
- heap sort: unstable because the deletemin procedure will potentially leapfrog duplicate keys to the root of the heap. Since the percolate down procedure stops when the parent value is less than or equal to its children values, a duplicate key that appears later in the original array could get promoted to the root and then stop above a duplicate key that appeared earlier in the original array. It would then be chosen earlier by the deletemin procedure, thus changing the original order of the keys. Note that the heapify routines that creates the heap preserves the order of duplicate keys because the percolate down procedure will not push a duplicate key down past another duplicate key.
- merge sort: stable because when faced with duplicate keys, the merge procedure always chooses the duplicate key from the left array. Hence duplicate keys that occur earlier in the array are placed before duplicate keys that occur later in the array.
- selection sort
- quicksort: You cannot use bucket sort because it works on integers, not real numbers.
- bucket sort: The number of buckets is limited because people do not work beyond 100, so the number of buckets can be limited to 0-100, and the number of buckets is much less than the number of employees.
- merge sort: Merge sort is the fastest of the stable sorting algorithms and you need a stable sorting algorithm to preserve the order of the duplicate keys.
- selection sort or heap sort: selection sort can find the 10 smallest employees in 10 passes, hence it will take O(N) time. heap sort can heapify the employees in O(N) time and find the 10 smallest employees with 10 deletemins that will cost 10 log N time. Hence the run time of heap sort is O(N) + O(log N), which is O(N). Which is fastest depends on constant factors and I'd have to implement both algorithms to find out which is faster. I would bet on heap sort but I'll take either answer.
- The insertion of 29 will cause the leaf containing the records {26, 28, 29, 31, 32} to split into two new leaves containing the records {26, 28, 29} and {30, 31, 32} respectively. A new key will be added to the parent, which currently has the keys {8, 18, 26, 35}. The added key will be 30 since the key of the smallest record in the new leaf is 30. Adding 30 to the parent would cause it to have the keys {8, 18, 26, 30, 35}, which is one key too many so the parent splits into two nodes containing the keys {8, 18} and {30, 35} respectively. The middle key, 26, gets promoted to the root and its left and right children will be the two nodes formed by the split of the parent node. Notice in the solution below that 26 is the smallest key in the right subtree pointed to by 26.
- 2 -- half of the maximum number of keys
- 3 -- half of the maximum number of records