The document discusses sorting algorithms and heap sort. It begins with an overview of comparison-based and distribution-based sorting algorithms such as selection sort, heap sort, insertion sort, merge sort, and quicksort. It then covers the implementation of an abstract sorting class with methods for comparing elements, swapping elements, and tracking comparisons and assignments. The document concludes with an explanation of how heap sort works by sinking nodes to construct a max-heap and then repeatedly swapping the root element with the rightmost leaf and sinking it to extract elements in sorted order.

1. Emory University Logo Guidelines
-
Sort:
Comparison-based
Data Structures and Algorithms
Emory University
Jinho D. Choi

2. Emory University Logo Guidelines
-
Sorting Algorithms
2

3. Emory University Logo Guidelines
-
Sorting Algorithms
2
Sort

4. Emory University Logo Guidelines
-
Sorting Algorithms
2
Sort
Comparison
based
Distribution
based

5. Emory University Logo Guidelines
-
Sorting Algorithms
2
Sort
Comparison
based
Distribution
based
Selection Insertion Merge Quick

6. Emory University Logo Guidelines
-
Sorting Algorithms
2
Sort
Comparison
based
Distribution
based
Selection
Heap
Insertion
Shell
Merge Quick
Tim Intro

7. Emory University Logo Guidelines
-
Sorting Algorithms
2
Sort
Comparison
based
Distribution
based
Bucket
Radix
Selection
Heap
Insertion
Shell
Merge Quick
Tim Intro

8. Emory University Logo Guidelines
-
Sorting Algorithms
2
Sort
Comparison
based
Distribution
based
Bucket
Radix
Selection
Heap
Insertion
Shell
Merge Quick
vs.?
Tim Intro

9. Emory University Logo Guidelines
-
Sorting Algorithms
2
Sort
Comparison
based
Distribution
based
Bucket
Radix
Selection
Heap
Insertion
Shell
Merge Quick
vs.?
Best in general?
Tim Intro

10. Emory University Logo Guidelines
-
Sorting Algorithms
2
Sort
Comparison
based
Distribution
based
Bucket
Radix
Selection
Heap
Insertion
Shell
Merge Quick
vs.?
Best in general?
When 1 < CPUs?
Tim Intro

11. Emory University Logo Guidelines
-
Sorting Algorithms
2
Sort
Comparison
based
Distribution
based
Bucket
Radix
Selection
Heap
Insertion
Shell
Merge Quick
vs.?
Best in general?
When range is known?
When 1 < CPUs?
Tim Intro

12. Emory University Logo Guidelines
-
Abstract Sort
3
public abstract class AbstractSort<T extends Comparable<T>>
{
protected Comparator<T> comparator;
protected long comparisons;
protected long assignments;
public AbstractSort(Comparator<T> comparator)
{
setComparator(comparator);
resetCounts();
}
public Comparator<T> getComparator()
{
return comparator;
}
public void setComparator(Comparator<T> comparator)
{
this.comparator = comparator;
}

13. Emory University Logo Guidelines
-
Abstract Sort
3
public abstract class AbstractSort<T extends Comparable<T>>
{
protected Comparator<T> comparator;
protected long comparisons;
protected long assignments;
public AbstractSort(Comparator<T> comparator)
{
setComparator(comparator);
resetCounts();
}
public Comparator<T> getComparator()
{
return comparator;
}
public void setComparator(Comparator<T> comparator)
{
this.comparator = comparator;
}

14. Emory University Logo Guidelines
-
Abstract Sort
3
public abstract class AbstractSort<T extends Comparable<T>>
{
protected Comparator<T> comparator;
protected long comparisons;
protected long assignments;
public AbstractSort(Comparator<T> comparator)
{
setComparator(comparator);
resetCounts();
}
public Comparator<T> getComparator()
{
return comparator;
}
public void setComparator(Comparator<T> comparator)
{
this.comparator = comparator;
}

15. Emory University Logo Guidelines
-
Abstract Sort
3
public abstract class AbstractSort<T extends Comparable<T>>
{
protected Comparator<T> comparator;
protected long comparisons;
protected long assignments;
public AbstractSort(Comparator<T> comparator)
{
setComparator(comparator);
resetCounts();
}
public Comparator<T> getComparator()
{
return comparator;
}
public void setComparator(Comparator<T> comparator)
{
this.comparator = comparator;
}
getter

16. Emory University Logo Guidelines
-
Abstract Sort
3
public abstract class AbstractSort<T extends Comparable<T>>
{
protected Comparator<T> comparator;
protected long comparisons;
protected long assignments;
public AbstractSort(Comparator<T> comparator)
{
setComparator(comparator);
resetCounts();
}
public Comparator<T> getComparator()
{
return comparator;
}
public void setComparator(Comparator<T> comparator)
{
this.comparator = comparator;
}
getter
setter

17. Emory University Logo Guidelines
-
Abstract Sort
4
public abstract class AbstractSort<T extends Comparable<T>>
{
protected Comparator<T> comparator;
protected long comparisons;
protected long assignments;
public AbstractSort(Comparator<T> comparator)
{
setComparator(comparator);
resetCounts();
}
...
public long getComparisonCount() {return comparisons;}
public long getAssignmentCount() {return assignments;}
public void resetCounts()
{
comparisons = 0;
assignments = 0;
}

18. Emory University Logo Guidelines
-
Abstract Sort
4
public abstract class AbstractSort<T extends Comparable<T>>
{
protected Comparator<T> comparator;
protected long comparisons;
protected long assignments;
public AbstractSort(Comparator<T> comparator)
{
setComparator(comparator);
resetCounts();
}
...
public long getComparisonCount() {return comparisons;}
public long getAssignmentCount() {return assignments;}
public void resetCounts()
{
comparisons = 0;
assignments = 0;
}
for benchmarking

19. Emory University Logo Guidelines
-
Abstract Sort
4
public abstract class AbstractSort<T extends Comparable<T>>
{
protected Comparator<T> comparator;
protected long comparisons;
protected long assignments;
public AbstractSort(Comparator<T> comparator)
{
setComparator(comparator);
resetCounts();
}
...
public long getComparisonCount() {return comparisons;}
public long getAssignmentCount() {return assignments;}
public void resetCounts()
{
comparisons = 0;
assignments = 0;
}
for benchmarking

20. Emory University Logo Guidelines
-
Abstract Sort
4
public abstract class AbstractSort<T extends Comparable<T>>
{
protected Comparator<T> comparator;
protected long comparisons;
protected long assignments;
public AbstractSort(Comparator<T> comparator)
{
setComparator(comparator);
resetCounts();
}
...
public long getComparisonCount() {return comparisons;}
public long getAssignmentCount() {return assignments;}
public void resetCounts()
{
comparisons = 0;
assignments = 0;
}
for benchmarking

21. Emory University Logo Guidelines
-
Abstract Sort
5
protected int compareTo(T[] array, int i, int j)
{
comparisons++;
return comparator.compare(array[i], array[j]);
}
protected void assign(T[] array, int index, T value)
{
assignments++;
array[index] = value;
}
protected void swap(T[] array, int i, int j)
{
T t = array[i];
assign(array, i, array[j]);
assign(array, j, t);
}

22. Emory University Logo Guidelines
-
Abstract Sort
5
protected int compareTo(T[] array, int i, int j)
{
comparisons++;
return comparator.compare(array[i], array[j]);
}
protected void assign(T[] array, int index, T value)
{
assignments++;
array[index] = value;
}
protected void swap(T[] array, int i, int j)
{
T t = array[i];
assign(array, i, array[j]);
assign(array, j, t);
}

23. Emory University Logo Guidelines
-
Abstract Sort
5
protected int compareTo(T[] array, int i, int j)
{
comparisons++;
return comparator.compare(array[i], array[j]);
}
protected void assign(T[] array, int index, T value)
{
assignments++;
array[index] = value;
}
protected void swap(T[] array, int i, int j)
{
T t = array[i];
assign(array, i, array[j]);
assign(array, j, t);
}

24. Emory University Logo Guidelines
-
Abstract Sort
6
/**
* Sorts the array[beginIndex:endIndex] in ascending order.
* @param array an array of comparable keys.
* @param beginIndex the index of the first key to be sorted (inclusive).
* @param endIndex the index of the last key to be sorted (exclusive).
*/
abstract public void sort(T[] array, int beginIndex, int endIndex);
public void sort(T[] array)
{
sort(array, 0, array.length);
}

25. Emory University Logo Guidelines
-
Abstract Sort
6
/**
* Sorts the array[beginIndex:endIndex] in ascending order.
* @param array an array of comparable keys.
* @param beginIndex the index of the first key to be sorted (inclusive).
* @param endIndex the index of the last key to be sorted (exclusive).
*/
abstract public void sort(T[] array, int beginIndex, int endIndex);
public void sort(T[] array)
{
sort(array, 0, array.length);
}
javadoc

26. Emory University Logo Guidelines
-
Selection-based Sort
7

27. Emory University Logo Guidelines
-
Selection-based Sort
• For each key ki in L[0, n-2]:
7

28. Emory University Logo Guidelines
-
Selection-based Sort
• For each key ki in L[0, n-2]:
- Search the minimum key kj in the L[i+1, n-1].
7

29. Emory University Logo Guidelines
-
Selection-based Sort
• For each key ki in L[0, n-2]:
- Search the minimum key kj in the L[i+1, n-1].
- Swap ki and kj.
7

30. Emory University Logo Guidelines
-
Selection-based Sort
• For each key ki in L[0, n-2]:
- Search the minimum key kj in the L[i+1, n-1].
- Swap ki and kj.
7
Search Compare Swap
Selection Linear O(n2) O(n)
Heap Heap O(n log n) O(n log n)

31. Emory University Logo Guidelines
-
Selection-based Sort
• For each key ki in L[0, n-2]:
- Search the minimum key kj in the L[i+1, n-1].
- Swap ki and kj.
7
Search Compare Swap
Selection Linear O(n2) O(n)
Heap Heap O(n log n) O(n log n)

32. Emory University Logo Guidelines
-
Selection-based Sort
• For each key ki in L[0, n-2]:
- Search the minimum key kj in the L[i+1, n-1].
- Swap ki and kj.
7
Search Compare Swap
Selection Linear O(n2) O(n)
Heap Heap O(n log n) O(n log n)

33. Emory University Logo Guidelines
-
Selection-based Sort
• For each key ki in L[0, n-2]:
- Search the minimum key kj in the L[i+1, n-1].
- Swap ki and kj.
7
Search Compare Swap
Selection Linear O(n2) O(n)
Heap Heap O(n log n) O(n log n)

34. Emory University Logo Guidelines
-
Selection-based Sort
• For each key ki in L[0, n-2]:
- Search the minimum key kj in the L[i+1, n-1].
- Swap ki and kj.
7
Search Compare Swap
Selection Linear O(n2) O(n)
Heap Heap O(n log n) O(n log n)

35. Emory University Logo Guidelines
-
Selection Sort
8
public void sort(T[] array, final int beginIndex, final int endIndex)
{
int min;
for (int i=beginIndex; i<endIndex-1; i++)
{
min = i;
for (int j=i+1; j<endIndex; j++)
{
if (compareTo(array, j, min) < 0)
min = j;
}
swap(array, i, min);
}
}

36. Emory University Logo Guidelines
-
Selection Sort
8
public void sort(T[] array, final int beginIndex, final int endIndex)
{
int min;
for (int i=beginIndex; i<endIndex-1; i++)
{
min = i;
for (int j=i+1; j<endIndex; j++)
{
if (compareTo(array, j, min) < 0)
min = j;
}
swap(array, i, min);
}
}
O(n2)

37. Emory University Logo Guidelines
-
Selection Sort
8
public void sort(T[] array, final int beginIndex, final int endIndex)
{
int min;
for (int i=beginIndex; i<endIndex-1; i++)
{
min = i;
for (int j=i+1; j<endIndex; j++)
{
if (compareTo(array, j, min) < 0)
min = j;
}
swap(array, i, min);
}
}
O(n2)
O(n)

38. Emory University Logo Guidelines
-
3 2 5 4 6 7 1
Heap Sort
9

39. Emory University Logo Guidelines
-
3 2 5 4 6 7 1
Heap Sort
9
Sink all non-leaf nodes to construct a heap.

40. Emory University Logo Guidelines
-
3 2 5 4 6 7 1
3
2 5
4 6 7 1
Heap Sort
9
Sink all non-leaf nodes to construct a heap.

41. Emory University Logo Guidelines
-
3 2 5 4 6 7 1
3
2 5
4 6 7 1
Heap Sort
9
Sink all non-leaf nodes to construct a heap.

42. Emory University Logo Guidelines
-
3 2 5 4 6 7 1
3
2 5
4 6 7 1
Heap Sort
9
Sink all non-leaf nodes to construct a heap.
6
2

43. Emory University Logo Guidelines
-
3 2 5 4 6 7 1
3
2 5
4 6 7 1
Heap Sort
9
Sink all non-leaf nodes to construct a heap.
6
2
6 2

44. Emory University Logo Guidelines
-
3 2 5 4 6 7 1
3
2 5
4 6 7 1
Heap Sort
9
Sink all non-leaf nodes to construct a heap.
6
2
6 2

45. Emory University Logo Guidelines
-
3 2 5 4 6 7 1
3
2 5
4 6 7 1
Heap Sort
9
Sink all non-leaf nodes to construct a heap.
6
2
7
5
6 2

46. Emory University Logo Guidelines
-
3 2 5 4 6 7 1
3
2 5
4 6 7 1
Heap Sort
9
Sink all non-leaf nodes to construct a heap.
6
2
7
5
6 27 5

47. Emory University Logo Guidelines
-
3 2 5 4 6 7 1
3
2 5
4 6 7 1
Heap Sort
9
Sink all non-leaf nodes to construct a heap.
6
2
7
5
6 27 5

48. Emory University Logo Guidelines
-
3 2 5 4 6 7 1
3
2 5
4 6 7 1
Heap Sort
9
Sink all non-leaf nodes to construct a heap.
6
2
7
5
7
3
6 27 5

49. Emory University Logo Guidelines
-
3 2 5 4 6 7 1
3
2 5
4 6 7 1
Heap Sort
9
Sink all non-leaf nodes to construct a heap.
6
2
7
5
7
3
6 27 57 3

50. Emory University Logo Guidelines
-
3 2 5 4 6 7 1
3
2 5
4 6 7 1
Heap Sort
9
Sink all non-leaf nodes to construct a heap.
6
2
7
5
7
3
6 27 57 3

51. Emory University Logo Guidelines
-
3 2 5 4 6 7 1
3
2 5
4 6 7 1
Heap Sort
9
Sink all non-leaf nodes to construct a heap.
6
2
7
5
7
35
3
6 27 57 3

52. Emory University Logo Guidelines
-
3 2 5 4 6 7 1
3
2 5
4 6 7 1
Heap Sort
9
Sink all non-leaf nodes to construct a heap.
6
2
7
5
7
35
3
6 27 57 35 3

53. Emory University Logo Guidelines
-
3 2 5 4 6 7 1
3
2 5
4 6 7 1
Heap Sort
9
Sink all non-leaf nodes to construct a heap.
6
2
7
5
7
35
3
6 27 57 35 3
Swap the rightmost leaf with the root, and sink.

54. Emory University Logo Guidelines
-
3 2 5 4 6 7 1
3
2 5
4 6 7 1
Heap Sort
9
Sink all non-leaf nodes to construct a heap.
6
2
7
5
7
35
3
6 27 57 35 3
Swap the rightmost leaf with the root, and sink.

55. Emory University Logo Guidelines
-
3 2 5 4 6 7 1
3
2 5
4 6 7 1
Heap Sort
9
Sink all non-leaf nodes to construct a heap.
6
2
7
5
7
35
3
6 27 57 35 3
1
7
Swap the rightmost leaf with the root, and sink.

56. Emory University Logo Guidelines
-
3 2 5 4 6 7 1
3
2 5
4 6 7 1
Heap Sort
9
Sink all non-leaf nodes to construct a heap.
6
2
7
5
7
35
3
6 27 57 35 3
1
1
7
7
Swap the rightmost leaf with the root, and sink.

57. Emory University Logo Guidelines
-
3 2 5 4 6 7 1
3
2 5
4 6 7 1
Heap Sort
9
Sink all non-leaf nodes to construct a heap.
6
2
7
5
7
35
3
6 27 57 35 3
1
1
7
7
Swap the rightmost leaf with the root, and sink.

58. Emory University Logo Guidelines
-
3 2 5 4 6 7 1
3
2 5
4 6 7 1
Heap Sort
9
Sink all non-leaf nodes to construct a heap.
6
2
7
5
7
35
3
6 27 57 35 3
1
1
7
7
6
1
Swap the rightmost leaf with the root, and sink.

59. Emory University Logo Guidelines
-
3 2 5 4 6 7 1
3
2 5
4 6 7 1
Heap Sort
9
Sink all non-leaf nodes to construct a heap.
6
2
7
5
7
35
3
6 27 57 35 3
1
1
7
7
6
6
1
1
Swap the rightmost leaf with the root, and sink.

60. Emory University Logo Guidelines
-
3 2 5 4 6 7 1
3
2 5
4 6 7 1
Heap Sort
9
Sink all non-leaf nodes to construct a heap.
6
2
7
5
7
35
3
6 27 57 35 3
1
1
7
7
6
6
1
1
Swap the rightmost leaf with the root, and sink.

61. Emory University Logo Guidelines
-
3 2 5 4 6 7 1
3
2 5
4 6 7 1
Heap Sort
9
Sink all non-leaf nodes to construct a heap.
6
2
7
5
7
35
3
6 27 57 35 3
1
1
7
7
6
6
1
1
4
1
Swap the rightmost leaf with the root, and sink.

62. Emory University Logo Guidelines
-
3 2 5 4 6 7 1
3
2 5
4 6 7 1
Heap Sort
9
Sink all non-leaf nodes to construct a heap.
6
2
7
5
7
35
3
6 27 57 35 3
1
1
7
7
6
6
1
1
4
4 1
1
Swap the rightmost leaf with the root, and sink.

63. Emory University Logo Guidelines
-
3 2 5 4 6 7 1
3
2 5
4 6 7 1
Heap Sort
9
Sink all non-leaf nodes to construct a heap.
6
2
7
5
7
35
3
6 27 57 35 3
1
1
7
7
6
6
1
1
4
4 1
1
Swap the rightmost leaf with the root, and sink.

64. Emory University Logo Guidelines
-
3 2 5 4 6 7 1
3
2 5
4 6 7 1
Heap Sort
9
Sink all non-leaf nodes to construct a heap.
6
2
7
5
7
35
3
6 27 57 35 3
1
1
7
7
6
6
1
1
4
4 1
1
3
6
Swap the rightmost leaf with the root, and sink.

65. Emory University Logo Guidelines
-
3 2 5 4 6 7 1
3
2 5
4 6 7 1
Heap Sort
9
Sink all non-leaf nodes to construct a heap.
6
2
7
5
7
35
3
6 27 57 35 3
1
1
7
7
6
6
1
1
4
4 1
1
3
6
3 6
Swap the rightmost leaf with the root, and sink.

66. Emory University Logo Guidelines
-
3 2 5 4 6 7 1
3
2 5
4 6 7 1
Heap Sort
9
Sink all non-leaf nodes to construct a heap.
6
2
7
5
7
35
3
6 27 57 35 3
1
1
7
7
6
6
1
1
4
4 1
1
3
6
3 6
Swap the rightmost leaf with the root, and sink.

67. Emory University Logo Guidelines
-
3 2 5 4 6 7 1
3
2 5
4 6 7 1
Heap Sort
9
Sink all non-leaf nodes to construct a heap.
6
2
7
5
7
35
3
6 27 57 35 3
1
1
7
7
6
6
1
1
4
4 1
1
3
6
3 6
5
3
Swap the rightmost leaf with the root, and sink.

68. Emory University Logo Guidelines
-
3 2 5 4 6 7 1
3
2 5
4 6 7 1
Heap Sort
9
Sink all non-leaf nodes to construct a heap.
6
2
7
5
7
35
3
6 27 57 35 3
1
1
7
7
6
6
1
1
4
4 1
1
3
6
3 6
5
5
3
3
Swap the rightmost leaf with the root, and sink.

69. Emory University Logo Guidelines
-
3 2 5 4 6 7 1
3
2 5
4 6 7 1
Heap Sort
9
Sink all non-leaf nodes to construct a heap.
6
2
7
5
7
35
3
6 27 57 35 3
1
1
7
7
6
6
1
1
4
4 1
1
3
6
3 6
5
5
3
3
Swap the rightmost leaf with the root, and sink.

70. Emory University Logo Guidelines
-
3 2 5 4 6 7 1
3
2 5
4 6 7 1
Heap Sort
9
Sink all non-leaf nodes to construct a heap.
6
2
7
5
7
35
3
6 27 57 35 3
1
1
7
7
6
6
1
1
4
4 1
1
3
6
3 6
5
5
3
3
2
5
Swap the rightmost leaf with the root, and sink.

71. Emory University Logo Guidelines
-
3 2 5 4 6 7 1
3
2 5
4 6 7 1
Heap Sort
9
Sink all non-leaf nodes to construct a heap.
6
2
7
5
7
35
3
6 27 57 35 3
1
1
7
7
6
6
1
1
4
4 1
1
3
6
3 6
5
5
3
3
2
2
5
5
Swap the rightmost leaf with the root, and sink.

72. Emory University Logo Guidelines
-
3 2 5 4 6 7 1
3
2 5
4 6 7 1
Heap Sort
9
Sink all non-leaf nodes to construct a heap.
6
2
7
5
7
35
3
6 27 57 35 3
1
1
7
7
6
6
1
1
4
4 1
1
3
6
3 6
5
5
3
3
2
2
5
5
Swap the rightmost leaf with the root, and sink.

73. Emory University Logo Guidelines
-
3 2 5 4 6 7 1
3
2 5
4 6 7 1
Heap Sort
9
Sink all non-leaf nodes to construct a heap.
6
2
7
5
7
35
3
6 27 57 35 3
1
1
7
7
6
6
1
1
4
4 1
1
3
6
3 6
5
5
3
3
2
2
5
5
4
2
Swap the rightmost leaf with the root, and sink.

74. Emory University Logo Guidelines
-
3 2 5 4 6 7 1
3
2 5
4 6 7 1
Heap Sort
9
Sink all non-leaf nodes to construct a heap.
6
2
7
5
7
35
3
6 27 57 35 3
1
1
7
7
6
6
1
1
4
4 1
1
3
6
3 6
5
5
3
3
2
2
5
5
4
4
2
2
Swap the rightmost leaf with the root, and sink.

75. Emory University Logo Guidelines
-
3 2 5 4 6 7 1
3
2 5
4 6 7 1
Heap Sort
9
Sink all non-leaf nodes to construct a heap.
6
2
7
5
7
35
3
6 27 57 35 3
1
1
7
7
6
6
1
1
4
4 1
1
3
6
3 6
5
5
3
3
2
2
5
5
4
4
2
2
Swap the rightmost leaf with the root, and sink.

76. Emory University Logo Guidelines
-
3 2 5 4 6 7 1
3
2 5
4 6 7 1
Heap Sort
9
Sink all non-leaf nodes to construct a heap.
6
2
7
5
7
35
3
6 27 57 35 3
1
1
7
7
6
6
1
1
4
4 1
1
3
6
3 6
5
5
3
3
2
2
5
5
4
4
2
2
1
4
Swap the rightmost leaf with the root, and sink.

77. Emory University Logo Guidelines
-
3 2 5 4 6 7 1
3
2 5
4 6 7 1
Heap Sort
9
Sink all non-leaf nodes to construct a heap.
6
2
7
5
7
35
3
6 27 57 35 3
1
1
7
7
6
6
1
1
4
4 1
1
3
6
3 6
5
5
3
3
2
2
5
5
4
4
2
2
1
1
4
4
Swap the rightmost leaf with the root, and sink.

78. Emory University Logo Guidelines
-
3 2 5 4 6 7 1
3
2 5
4 6 7 1
Heap Sort
9
Sink all non-leaf nodes to construct a heap.
6
2
7
5
7
35
3
6 27 57 35 3
1
1
7
7
6
6
1
1
4
4 1
1
3
6
3 6
5
5
3
3
2
2
5
5
4
4
2
2
1
1
4
4
Swap the rightmost leaf with the root, and sink.

79. Emory University Logo Guidelines
-
3 2 5 4 6 7 1
3
2 5
4 6 7 1
Heap Sort
9
Sink all non-leaf nodes to construct a heap.
6
2
7
5
7
35
3
6 27 57 35 3
1
1
7
7
6
6
1
1
4
4 1
1
3
6
3 6
5
5
3
3
2
2
5
5
4
4
2
2
1
1
4
4
3
1
Swap the rightmost leaf with the root, and sink.

80. Emory University Logo Guidelines
-
3 2 5 4 6 7 1
3
2 5
4 6 7 1
Heap Sort
9
Sink all non-leaf nodes to construct a heap.
6
2
7
5
7
35
3
6 27 57 35 3
1
1
7
7
6
6
1
1
4
4 1
1
3
6
3 6
5
5
3
3
2
2
5
5
4
4
2
2
1
1
4
4
3
3
1
1
Swap the rightmost leaf with the root, and sink.

81. Emory University Logo Guidelines
-
3 2 5 4 6 7 1
3
2 5
4 6 7 1
Heap Sort
9
Sink all non-leaf nodes to construct a heap.
6
2
7
5
7
35
3
6 27 57 35 3
1
1
7
7
6
6
1
1
4
4 1
1
3
6
3 6
5
5
3
3
2
2
5
5
4
4
2
2
1
1
4
4
3
3
1
1
Swap the rightmost leaf with the root, and sink.

82. Emory University Logo Guidelines
-
3 2 5 4 6 7 1
3
2 5
4 6 7 1
Heap Sort
9
Sink all non-leaf nodes to construct a heap.
6
2
7
5
7
35
3
6 27 57 35 3
1
1
7
7
6
6
1
1
4
4 1
1
3
6
3 6
5
5
3
3
2
2
5
5
4
4
2
2
1
1
4
4
3
3
1
1
1
3
Swap the rightmost leaf with the root, and sink.

83. Emory University Logo Guidelines
-
3 2 5 4 6 7 1
3
2 5
4 6 7 1
Heap Sort
9
Sink all non-leaf nodes to construct a heap.
6
2
7
5
7
35
3
6 27 57 35 3
1
1
7
7
6
6
1
1
4
4 1
1
3
6
3 6
5
5
3
3
2
2
5
5
4
4
2
2
1
1
4
4
3
3
1
1
1
3
1 3
Swap the rightmost leaf with the root, and sink.

84. Emory University Logo Guidelines
-
3 2 5 4 6 7 1
3
2 5
4 6 7 1
Heap Sort
9
Sink all non-leaf nodes to construct a heap.
6
2
7
5
7
35
3
6 27 57 35 3
1
1
7
7
6
6
1
1
4
4 1
1
3
6
3 6
5
5
3
3
2
2
5
5
4
4
2
2
1
1
4
4
3
3
1
1
1
3
1 3
Swap the rightmost leaf with the root, and sink.

85. Emory University Logo Guidelines
-
3 2 5 4 6 7 1
3
2 5
4 6 7 1
Heap Sort
9
Sink all non-leaf nodes to construct a heap.
6
2
7
5
7
35
3
6 27 57 35 3
1
1
7
7
6
6
1
1
4
4 1
1
3
6
3 6
5
5
3
3
2
2
5
5
4
4
2
2
1
1
4
4
3
3
1
1
1
3
1 3
2
1
Swap the rightmost leaf with the root, and sink.

86. Emory University Logo Guidelines
-
3 2 5 4 6 7 1
3
2 5
4 6 7 1
Heap Sort
9
Sink all non-leaf nodes to construct a heap.
6
2
7
5
7
35
3
6 27 57 35 3
1
1
7
7
6
6
1
1
4
4 1
1
3
6
3 6
5
5
3
3
2
2
5
5
4
4
2
2
1
1
4
4
3
3
1
1
1
3
1 3
2
1
2 1
Swap the rightmost leaf with the root, and sink.

87. Emory University Logo Guidelines
-
3 2 5 4 6 7 1
3
2 5
4 6 7 1
Heap Sort
9
Sink all non-leaf nodes to construct a heap.
6
2
7
5
7
35
3
6 27 57 35 3
1
1
7
7
6
6
1
1
4
4 1
1
3
6
3 6
5
5
3
3
2
2
5
5
4
4
2
2
1
1
4
4
3
3
1
1
1
3
1 3
2
1
2 1
Swap the rightmost leaf with the root, and sink.

88. Emory University Logo Guidelines
-
3 2 5 4 6 7 1
3
2 5
4 6 7 1
Heap Sort
9
Sink all non-leaf nodes to construct a heap.
6
2
7
5
7
35
3
6 27 57 35 3
1
1
7
7
6
6
1
1
4
4 1
1
3
6
3 6
5
5
3
3
2
2
5
5
4
4
2
2
1
1
4
4
3
3
1
1
1
3
1 3
2
1
2 1
1
2
Swap the rightmost leaf with the root, and sink.

89. Emory University Logo Guidelines
-
3 2 5 4 6 7 1
3
2 5
4 6 7 1
Heap Sort
9
Sink all non-leaf nodes to construct a heap.
6
2
7
5
7
35
3
6 27 57 35 3
1
1
7
7
6
6
1
1
4
4 1
1
3
6
3 6
5
5
3
3
2
2
5
5
4
4
2
2
1
1
4
4
3
3
1
1
1
3
1 3
2
1
2 1
1
2
1 2
Swap the rightmost leaf with the root, and sink.

90. Emory University Logo Guidelines
-
3 2 5 4 6 7 1
3
2 5
4 6 7 1
Heap Sort
9
Sink all non-leaf nodes to construct a heap.
6
2
7
5
7
35
3
6 27 57 35 3
1
1
7
7
6
6
1
1
4
4 1
1
3
6
3 6
5
5
3
3
2
2
5
5
4
4
2
2
1
1
4
4
3
3
1
1
1
3
1 3
2
1
2 1
1
2
1 2
Swap the rightmost leaf with the root, and sink.

91. Emory University Logo Guidelines
-
3 2 5 4 6 7 1
3
2 5
4 6 7 1
Heap Sort
9
Sink all non-leaf nodes to construct a heap.
6
2
7
5
7
35
3
6 27 57 35 3
1
1
7
7
6
6
1
1
4
4 1
1
3
6
3 6
5
5
3
3
2
2
5
5
4
4
2
2
1
1
4
4
3
3
1
1
1
3
1 3
2
1
2 1
1
2
1 2
Swap the rightmost leaf with the root, and sink.
# of comparison?

92. Emory University Logo Guidelines
-
private int getParentIndex(int beginIndex, int k)
{
return beginIndex + (k-beginIndex)/2 - 1;
}
private int getLeftChildIndex(int beginIndex, int k)
{
return beginIndex + 2*(k-beginIndex) + 1;
}
Heap Sort
10
public void sort(T[] array, int beginIndex, int endIndex)
{
for (int k=getParentIndex(beginIndex, endIndex); k>=beginIndex; k--)
sink(array, k, beginIndex, endIndex);
while (endIndex > beginIndex+1)
{
swap(array, beginIndex, --endIndex);
sink(array, beginIndex, beginIndex, endIndex);
}
}

93. Emory University Logo Guidelines
-
private int getParentIndex(int beginIndex, int k)
{
return beginIndex + (k-beginIndex)/2 - 1;
}
private int getLeftChildIndex(int beginIndex, int k)
{
return beginIndex + 2*(k-beginIndex) + 1;
}
Heap Sort
10
public void sort(T[] array, int beginIndex, int endIndex)
{
for (int k=getParentIndex(beginIndex, endIndex); k>=beginIndex; k--)
sink(array, k, beginIndex, endIndex);
while (endIndex > beginIndex+1)
{
swap(array, beginIndex, --endIndex);
sink(array, beginIndex, beginIndex, endIndex);
}
}

94. Emory University Logo Guidelines
-
private int getParentIndex(int beginIndex, int k)
{
return beginIndex + (k-beginIndex)/2 - 1;
}
private int getLeftChildIndex(int beginIndex, int k)
{
return beginIndex + 2*(k-beginIndex) + 1;
}
Heap Sort
10
public void sort(T[] array, int beginIndex, int endIndex)
{
for (int k=getParentIndex(beginIndex, endIndex); k>=beginIndex; k--)
sink(array, k, beginIndex, endIndex);
while (endIndex > beginIndex+1)
{
swap(array, beginIndex, --endIndex);
sink(array, beginIndex, beginIndex, endIndex);
}
}

95. Emory University Logo Guidelines
-
private int getParentIndex(int beginIndex, int k)
{
return beginIndex + (k-beginIndex)/2 - 1;
}
private int getLeftChildIndex(int beginIndex, int k)
{
return beginIndex + 2*(k-beginIndex) + 1;
}
Heap Sort
10
public void sort(T[] array, int beginIndex, int endIndex)
{
for (int k=getParentIndex(beginIndex, endIndex); k>=beginIndex; k--)
sink(array, k, beginIndex, endIndex);
while (endIndex > beginIndex+1)
{
swap(array, beginIndex, --endIndex);
sink(array, beginIndex, beginIndex, endIndex);
}
}

96. Emory University Logo Guidelines
-
Insertion-based Sort
11

97. Emory University Logo Guidelines
-
Insertion-based Sort
• For each key ki in L[1, n-1]:
11

98. Emory University Logo Guidelines
-
Insertion-based Sort
• For each key ki in L[1, n-1]:
- Keep swapping ki-1 and ki until ki-1 ≤ ki.
11

99. Emory University Logo Guidelines
-
Insertion-based Sort
• For each key ki in L[1, n-1]:
- Keep swapping ki-1 and ki until ki-1 ≤ ki.
11
Pair Compare Swap
Insertion Adjacent O(n2) O(n2)
Shell
By Knuth
Sequence
O(n1.5) O(n1.5)

100. Emory University Logo Guidelines
-
Insertion-based Sort
• For each key ki in L[1, n-1]:
- Keep swapping ki-1 and ki until ki-1 ≤ ki.
11
Pair Compare Swap
Insertion Adjacent O(n2) O(n2)
Shell
By Knuth
Sequence
O(n1.5) O(n1.5)

101. Emory University Logo Guidelines
-
Insertion-based Sort
• For each key ki in L[1, n-1]:
- Keep swapping ki-1 and ki until ki-1 ≤ ki.
11
Pair Compare Swap
Insertion Adjacent O(n2) O(n2)
Shell
By Knuth
Sequence
O(n1.5) O(n1.5)

102. Emory University Logo Guidelines
-
Insertion Sort
12
public void sort(T[] array, int beginIndex, int endIndex)
{
sort(array, beginIndex, endIndex, 1);
}
protected void sort(T[] array, int beginIndex, int endIndex, final int h)
{
int beginH = beginIndex + h;
for (int i=beginH; i<endIndex; i++)
for (int j=i; j>=beginH && compareTo(array, j, j-h) < 0; j-=h)
swap(array, j, j-h);
}

103. Emory University Logo Guidelines
-
Insertion Sort
12
public void sort(T[] array, int beginIndex, int endIndex)
{
sort(array, beginIndex, endIndex, 1);
}
protected void sort(T[] array, int beginIndex, int endIndex, final int h)
{
int beginH = beginIndex + h;
for (int i=beginH; i<endIndex; i++)
for (int j=i; j>=beginH && compareTo(array, j, j-h) < 0; j-=h)
swap(array, j, j-h);
}

104. Emory University Logo Guidelines
-
Insertion Sort
12
public void sort(T[] array, int beginIndex, int endIndex)
{
sort(array, beginIndex, endIndex, 1);
}
protected void sort(T[] array, int beginIndex, int endIndex, final int h)
{
int beginH = beginIndex + h;
for (int i=beginH; i<endIndex; i++)
for (int j=i; j>=beginH && compareTo(array, j, j-h) < 0; j-=h)
swap(array, j, j-h);
}
Advantage over selection sort?

105. Emory University Logo Guidelines
-
Insertion Sort
12
public void sort(T[] array, int beginIndex, int endIndex)
{
sort(array, beginIndex, endIndex, 1);
}
protected void sort(T[] array, int beginIndex, int endIndex, final int h)
{
int beginH = beginIndex + h;
for (int i=beginH; i<endIndex; i++)
for (int j=i; j>=beginH && compareTo(array, j, j-h) < 0; j-=h)
swap(array, j, j-h);
}
Advantage over selection sort?
41 1 2 3 4 5 6 7 8 9 10111213141516171819202122232425262728293031323334353637383940 0

106. Emory University Logo Guidelines
-
Insertion Sort
12
public void sort(T[] array, int beginIndex, int endIndex)
{
sort(array, beginIndex, endIndex, 1);
}
protected void sort(T[] array, int beginIndex, int endIndex, final int h)
{
int beginH = beginIndex + h;
for (int i=beginH; i<endIndex; i++)
for (int j=i; j>=beginH && compareTo(array, j, j-h) < 0; j-=h)
swap(array, j, j-h);
}
Advantage over selection sort?
41 1 2 3 4 5 6 7 8 9 10111213141516171819202122232425262728293031323334353637383940 0

107. Emory University Logo Guidelines
-
Insertion Sort
12
public void sort(T[] array, int beginIndex, int endIndex)
{
sort(array, beginIndex, endIndex, 1);
}
protected void sort(T[] array, int beginIndex, int endIndex, final int h)
{
int beginH = beginIndex + h;
for (int i=beginH; i<endIndex; i++)
for (int j=i; j>=beginH && compareTo(array, j, j-h) < 0; j-=h)
swap(array, j, j-h);
}
Advantage over selection sort?
How many swaps?
41 1 2 3 4 5 6 7 8 9 10111213141516171819202122232425262728293031323334353637383940 0

108. Emory University Logo Guidelines
-
Insertion Sort
12
public void sort(T[] array, int beginIndex, int endIndex)
{
sort(array, beginIndex, endIndex, 1);
}
protected void sort(T[] array, int beginIndex, int endIndex, final int h)
{
int beginH = beginIndex + h;
for (int i=beginH; i<endIndex; i++)
for (int j=i; j>=beginH && compareTo(array, j, j-h) < 0; j-=h)
swap(array, j, j-h);
}
Advantage over selection sort?
How many swaps?
Can we avoid unnecessary swaps?
41 1 2 3 4 5 6 7 8 9 10111213141516171819202122232425262728293031323334353637383940 0

109. Emory University Logo Guidelines
-
Shell Sort
13
41 1 2 3 4 5 6 7 8 9 10111213141516171819202122232425262728293031323334353637383940 0

110. Emory University Logo Guidelines
-
Shell Sort
13
41 1 2 3 4 5 6 7 8 9 10111213141516171819202122232425262728293031323334353637383940 0
Group keys whose distance is defined by a sequence:

111. Emory University Logo Guidelines
-
Shell Sort
13
41 1 2 3 4 5 6 7 8 9 10111213141516171819202122232425262728293031323334353637383940 0
14, 4, 1 < N / 3, where N = 42
Group keys whose distance is defined by a sequence:

112. Emory University Logo Guidelines
-
Shell Sort
13
41 1 2 3 4 5 6 7 8 9 10111213141516171819202122232425262728293031323334353637383940 0
14, 4, 1 < N / 3, where N = 42
Group keys whose distance is defined by a sequence:

113. Emory University Logo Guidelines
-
Shell Sort
13
41 1 2 3 4 5 6 7 8 9 10111213141516171819202122232425262728293031323334353637383940 0
14, 4, 1 < N / 3, where N = 42
Group keys whose distance is defined by a sequence:
Sort each group using insertion sort

114. Emory University Logo Guidelines
-
Shell Sort
13
41 1 2 3 4 5 6 7 8 9 10111213141516171819202122232425262728293031323334353637383940 0
14, 4, 1 < N / 3, where N = 42
Only 4 keys to swaps!
Group keys whose distance is defined by a sequence:
Sort each group using insertion sort

115. Emory University Logo Guidelines
-
Shell Sort
13
41 1 2 3 4 5 6 7 8 9 10111213141516171819202122232425262728293031323334353637383940 0
14, 4, 1 < N / 3, where N = 42
Only 4 keys to swaps!
Group keys whose distance is defined by a sequence:
Sort each group using insertion sort
Shell: n / 2k (n = 1000) ⇒ 500, 250, 125, …
Pratt: 2p ⋅ 3q ⇒ 1, 2, 3, 4, 6, 8, 9, 12, …
Hibbard: 2p ⋅ 3q ⇒ 1, 2, 3, 4, 6, 8, 9, 12, …
Knuth: (3t - 1) / 2 ⇒ 1, 4, 14, 40, 121, …

116. Emory University Logo Guidelines
-
Shell Sort
14
3 2 5 4 6 7 1

117. Emory University Logo Guidelines
-
Shell Sort
14
3 2 5 4 6 7 1
Hibbard Sequence: 1, 3, 7, 15, …

118. Emory University Logo Guidelines
-
Shell Sort
14
3 2 5 4 6 7 1
Hibbard Sequence: 1, 3, 7, 15, …
k1 = 3

119. Emory University Logo Guidelines
-
Shell Sort
14
3 2 5 4 6 7 1
Hibbard Sequence: 1, 3, 7, 15, …
k1 = 3

120. Emory University Logo Guidelines
-
Shell Sort
14
3 2 5 4 6 7 1
Hibbard Sequence: 1, 3, 7, 15, …
k1 = 3
1 4

121. Emory University Logo Guidelines
-
Shell Sort
14
3 2 5 4 6 7 1
Hibbard Sequence: 1, 3, 7, 15, …
k1 = 3
1 41 3

122. Emory University Logo Guidelines
-
Shell Sort
14
3 2 5 4 6 7 1
Hibbard Sequence: 1, 3, 7, 15, …
k1 = 3
1 41 3

123. Emory University Logo Guidelines
-
Shell Sort
14
3 2 5 4 6 7 1
Hibbard Sequence: 1, 3, 7, 15, …
k1 = 3
1 41 3

124. Emory University Logo Guidelines
-
Shell Sort
14
3 2 5 4 6 7 1
Hibbard Sequence: 1, 3, 7, 15, …
k1 = 3
1 41 3

125. Emory University Logo Guidelines
-
Shell Sort
14
3 2 5 4 6 7 1
Hibbard Sequence: 1, 3, 7, 15, …
k1 = 3
1 41 3
k0 = 1

126. Emory University Logo Guidelines
-
Shell Sort
14
3 2 5 4 6 7 1
Hibbard Sequence: 1, 3, 7, 15, …
k1 = 3
1 41 3
k0 = 1

127. Emory University Logo Guidelines
-
Shell Sort
14
3 2 5 4 6 7 1
Hibbard Sequence: 1, 3, 7, 15, …
k1 = 3
1 41 3
k0 = 1

128. Emory University Logo Guidelines
-
Shell Sort
14
3 2 5 4 6 7 1
Hibbard Sequence: 1, 3, 7, 15, …
k1 = 3
1 41 3
k0 = 1

129. Emory University Logo Guidelines
-
Shell Sort
14
3 2 5 4 6 7 1
Hibbard Sequence: 1, 3, 7, 15, …
k1 = 3
1 41 3
k0 = 1
3 5

130. Emory University Logo Guidelines
-
Shell Sort
14
3 2 5 4 6 7 1
Hibbard Sequence: 1, 3, 7, 15, …
k1 = 3
1 41 3
k0 = 1
3 5

131. Emory University Logo Guidelines
-
Shell Sort
14
3 2 5 4 6 7 1
Hibbard Sequence: 1, 3, 7, 15, …
k1 = 3
1 41 3
k0 = 1
3 5

132. Emory University Logo Guidelines
-
Shell Sort
14
3 2 5 4 6 7 1
Hibbard Sequence: 1, 3, 7, 15, …
k1 = 3
1 41 3
k0 = 1
3 5

133. Emory University Logo Guidelines
-
Shell Sort
14
3 2 5 4 6 7 1
Hibbard Sequence: 1, 3, 7, 15, …
k1 = 3
1 41 3
k0 = 1
3 5 4 7

134. Emory University Logo Guidelines
-
Shell Sort
14
3 2 5 4 6 7 1
Hibbard Sequence: 1, 3, 7, 15, …
k1 = 3
1 41 3
k0 = 1
3 5 4 74 6

135. Emory University Logo Guidelines
-
Shell Sort
14
3 2 5 4 6 7 1
Hibbard Sequence: 1, 3, 7, 15, …
k1 = 3
1 41 3
k0 = 1
3 5 4 74 64 5

136. Emory University Logo Guidelines
-
Shell Sort
14
3 2 5 4 6 7 1
Hibbard Sequence: 1, 3, 7, 15, …
k1 = 3
1 41 3
k0 = 1
3 5 4 74 64 5

137. Emory University Logo Guidelines
-
Shell Sort
15
public abstract class ShellSort<T extends Comparable<T>> extends InsertionSort<T>
{
protected List<Integer> sequence;
public ShellSort(Comparator<T> comparator, int n)
{
super(comparator);
sequence = new ArrayList<>();
populateSequence(n);
}
protected abstract void populateSequence(int n);
...
}

138. Emory University Logo Guidelines
-
Shell Sort
15
public abstract class ShellSort<T extends Comparable<T>> extends InsertionSort<T>
{
protected List<Integer> sequence;
public ShellSort(Comparator<T> comparator, int n)
{
super(comparator);
sequence = new ArrayList<>();
populateSequence(n);
}
protected abstract void populateSequence(int n);
...
}

139. Emory University Logo Guidelines
-
Shell Sort
15
public abstract class ShellSort<T extends Comparable<T>> extends InsertionSort<T>
{
protected List<Integer> sequence;
public ShellSort(Comparator<T> comparator, int n)
{
super(comparator);
sequence = new ArrayList<>();
populateSequence(n);
}
protected abstract void populateSequence(int n);
...
}
pre-populate the sequence

140. Emory University Logo Guidelines
-
Shell Sort
16
public abstract class ShellSort<T extends Comparable<T>> extends InsertionSort<T>
{
...
@Override
public void sort(T[] array, int beginIndex, int endIndex)
{
int n = endIndex - beginIndex;
populateSequence(n);
for (int i=getSequenceStartIndex(n); i>=0; i--)
sort(array, beginIndex, endIndex, sequence.get(i));
}
protected abstract int getSequenceStartIndex(int n);
}

141. Emory University Logo Guidelines
-
Shell Sort
16
public abstract class ShellSort<T extends Comparable<T>> extends InsertionSort<T>
{
...
@Override
public void sort(T[] array, int beginIndex, int endIndex)
{
int n = endIndex - beginIndex;
populateSequence(n);
for (int i=getSequenceStartIndex(n); i>=0; i--)
sort(array, beginIndex, endIndex, sequence.get(i));
}
protected abstract int getSequenceStartIndex(int n);
}

142. Emory University Logo Guidelines
-
Shell Sort
16
public abstract class ShellSort<T extends Comparable<T>> extends InsertionSort<T>
{
...
@Override
public void sort(T[] array, int beginIndex, int endIndex)
{
int n = endIndex - beginIndex;
populateSequence(n);
for (int i=getSequenceStartIndex(n); i>=0; i--)
sort(array, beginIndex, endIndex, sequence.get(i));
}
protected abstract int getSequenceStartIndex(int n);
}

143. Emory University Logo Guidelines
-
Shell Sort
17
public abstract class ShellSort<T extends Comparable<T>> extends InsertionSort<T>
{
public ShellSort(Comparator<T> comparator)
{
super(comparator);
}
@Override
public void sort(T[] array, int beginIndex, int endIndex)
{
int n = endIndex - beginIndex;
for (int t=1, h=getH(n, t); h <= 1; h=getH(n, t), t++)
sort(array, beginIndex, endIndex, h);
}
protected abstract int getH(int n, int t);
}

144. Emory University Logo Guidelines
-
Shell Sort
17
public abstract class ShellSort<T extends Comparable<T>> extends InsertionSort<T>
{
public ShellSort(Comparator<T> comparator)
{
super(comparator);
}
@Override
public void sort(T[] array, int beginIndex, int endIndex)
{
int n = endIndex - beginIndex;
for (int t=1, h=getH(n, t); h <= 1; h=getH(n, t), t++)
sort(array, beginIndex, endIndex, h);
}
protected abstract int getH(int n, int t);
}

145. Emory University Logo Guidelines
-
Shell Sort
17
public abstract class ShellSort<T extends Comparable<T>> extends InsertionSort<T>
{
public ShellSort(Comparator<T> comparator)
{
super(comparator);
}
@Override
public void sort(T[] array, int beginIndex, int endIndex)
{
int n = endIndex - beginIndex;
for (int t=1, h=getH(n, t); h <= 1; h=getH(n, t), t++)
sort(array, beginIndex, endIndex, h);
}
protected abstract int getH(int n, int t);
}

146. Emory University Logo Guidelines
-
Shell Sort
17
public abstract class ShellSort<T extends Comparable<T>> extends InsertionSort<T>
{
public ShellSort(Comparator<T> comparator)
{
super(comparator);
}
@Override
public void sort(T[] array, int beginIndex, int endIndex)
{
int n = endIndex - beginIndex;
for (int t=1, h=getH(n, t); h <= 1; h=getH(n, t), t++)
sort(array, beginIndex, endIndex, h);
}
protected abstract int getH(int n, int t);
}

147. Emory University Logo Guidelines
-
Shell Sort
17
public abstract class ShellSort<T extends Comparable<T>> extends InsertionSort<T>
{
public ShellSort(Comparator<T> comparator)
{
super(comparator);
}
@Override
public void sort(T[] array, int beginIndex, int endIndex)
{
int n = endIndex - beginIndex;
for (int t=1, h=getH(n, t); h <= 1; h=getH(n, t), t++)
sort(array, beginIndex, endIndex, h);
}
protected abstract int getH(int n, int t);
}

148. Emory University Logo Guidelines
-
Shell Sort Knuth
18
@Override
protected void populateSequence(int n)
{
n /= 3;
for (int t=sequence.size()+1; ; t++)
{
int h = (int)((Math.pow(3, t) - 1) / 2);
if (h <= n) sequence.add(h);
else break;
}
}
@Override
protected int getSequenceStartIndex(int n)
{
int index = Collections.binarySearch(sequence, n/3);
if (index < 0) index = -(index+1);
if (index == sequence.size()) index--;
return index;
}

149. Emory University Logo Guidelines
-
Shell Sort Knuth
18
@Override
protected void populateSequence(int n)
{
n /= 3;
for (int t=sequence.size()+1; ; t++)
{
int h = (int)((Math.pow(3, t) - 1) / 2);
if (h <= n) sequence.add(h);
else break;
}
}
@Override
protected int getSequenceStartIndex(int n)
{
int index = Collections.binarySearch(sequence, n/3);
if (index < 0) index = -(index+1);
if (index == sequence.size()) index--;
return index;
}
upper bound

150. Emory University Logo Guidelines
-
Shell Sort Knuth
18
@Override
protected void populateSequence(int n)
{
n /= 3;
for (int t=sequence.size()+1; ; t++)
{
int h = (int)((Math.pow(3, t) - 1) / 2);
if (h <= n) sequence.add(h);
else break;
}
}
@Override
protected int getSequenceStartIndex(int n)
{
int index = Collections.binarySearch(sequence, n/3);
if (index < 0) index = -(index+1);
if (index == sequence.size()) index--;
return index;
}
upper bound

151. Emory University Logo Guidelines
-
Comparison - Comparison (Random)
19
Σofcomparisons
List sizes
100 200 300 400 500 600 700 800 900 1000
Heap Shell Selection Insertion

152. Emory University Logo Guidelines
-
Comparison - Assignment (Random)
20
Σofassignments
List sizes
100 200 300 400 500 600 700 800 900 1000
Heap Shell Selection Insertion

153. Emory University Logo Guidelines
-
Comparison - Speed (Random)
21
Σof1Kiterations(ms)
0
1500
3000
4500
6000
List sizes
100 200 300 400 500 600 700 800 900 1000
Heap Shell Selection Insertion

154. Emory University Logo Guidelines
-
Comparison - Speed (Ascending)
22
Σof1Kiterations(ms)
0
1000
2000
3000
4000
List sizes
100 200 300 400 500 600 700 800 900 1000
Heap Shell Selection Insertion

155. Emory University Logo Guidelines
-
Comparison - Speed (Descending)
23
Σof1Kiterations(ms)
0
3500
7000
10500
14000
List sizes
100 200 300 400 500 600 700 800 900 1000
Heap Shell Selection Insertion

156. Emory University Logo Guidelines
-
Agenda
• Exercise
- https://github.com/emory-courses/cs323/wiki/Divide-and-Conquer-Sort
• Reading
- https://en.wikipedia.org/wiki/Merge_sort
- https://en.wikipedia.org/wiki/Quicksort
- https://en.wikipedia.org/wiki/Introsort
- https://en.wikipedia.org/wiki/Timsort
24