CS253: Divide & Conquer Sort (2019)
1 like100 views
The document discusses two sorting algorithms: Quicksort and Mergesort. Quicksort works by picking a pivot element and partitioning the array around that pivot, recursively sorting the subarrays. It has average time complexity of O(n log n) but worst case of O(n^2). Mergesort works by dividing the array into halves, recursively sorting the halves, and then merging the sorted halves together. It has time complexity of O(n log n) in all cases. The document also includes Java code for implementing MergeSort and discusses how it works.
![MergeSort.java
public class MergeSort<T extends Comparable<T>> extends AbstractSort<T> {
private T[] temp;
@Override
public void sort(T[] array, int beginIndex, int endIndex) {
if (beginIndex + 1 >= endIndex) return;
int middleIndex = Utils.getMiddleIndex(beginIndex, endIndex);
// sort left partition
sort(array, beginIndex, middleIndex);
// sort Right partition
sort(array, middleIndex, endIndex);
// merge partitions
merge(array, beginIndex, middleIndex, endIndex);
}
T[] temp
Utils.getMiddleIndex()](https://image.slidesharecdn.com/sortdivideconquer-190925013847/85/CS253-Divide-Conquer-Sort-2019-29-320.jpg)
![private void copy(T[] array, int beginIndex, int endIndex) {
int N = array.length;
if (temp == null || temp.length < N)
temp = Arrays.copyOf(array, N);
else {
N = endIndex - beginIndex;
System.arraycopy(array, beginIndex, temp, beginIndex, N);
}
assignments += N;
}
Arrays.copyOf() System.arraycopy()
temp
temp](https://image.slidesharecdn.com/sortdivideconquer-190925013847/85/CS253-Divide-Conquer-Sort-2019-30-320.jpg)
![/**
* @param beginIndex the beginning index of the 1st half (inclusive).
* @param middleIndex the ending index of the 1st half (exclusive).
* @param endIndex the ending index of the 2nd half (exclusive).
*/
private void merge(T[] array, int beginIndex, int middleIndex, int endIndex) {
int fst = beginIndex, snd = middleIndex;
copy(array, beginIndex, endIndex);
for (int k = beginIndex; k < endIndex; k++) {
if (fst >= middleIndex) // no key left in the 1st half
assign(array, k, temp[snd++]);
else if (snd >= endIndex) // no key left in the 2nd half
assign(array, k, temp[fst++]);
else if (compareTo(temp, fst, snd) < 0) // 1st key < 2nd key
assign(array, k, temp[fst++]);
else
assign(array, k, temp[snd++]);
}
}](https://image.slidesharecdn.com/sortdivideconquer-190925013847/85/CS253-Divide-Conquer-Sort-2019-31-320.jpg)
![QuickSort.java
@Override
public void sort(T[] array, int beginIndex, int endIndex) {
// at least one key in the range
if (beginIndex >= endIndex) return;
int pivotIndex = partition(array, beginIndex, endIndex);
// sort left partition
sort(array, beginIndex, pivotIndex);
// sort right partition
sort(array, pivotIndex + 1, endIndex);
}](https://image.slidesharecdn.com/sortdivideconquer-190925013847/85/CS253-Divide-Conquer-Sort-2019-53-320.jpg)
![protected int partition(T[] array, int beginIndex, int endIndex) {
int fst = beginIndex, snd = endIndex;
while (true) {
// Find where endIndex > fst > pivot
while (++fst < endIndex && compareTo(array, beginIndex, fst) >= 0);
// Find where beginIndex < snd < pivot
while (--snd > beginIndex && compareTo(array, beginIndex, snd) <= 0);
// pointers crossed
if (fst >= snd) break;
// exchange
swap(array, fst, snd);
}
// set pivot
swap(array, beginIndex, snd);
return snd;
}](https://image.slidesharecdn.com/sortdivideconquer-190925013847/85/CS253-Divide-Conquer-Sort-2019-54-320.jpg)
![@Override
public void sort(T[] array, int beginIndex, int endIndex) {
final int maxdepth = getMaxDepth(beginIndex, endIndex);
introsort(array, beginIndex, endIndex, maxdepth);
comparisons += engine.getComparisonCount();
assignments += engine.getAssignmentCount();
}
protected int getMaxDepth(int beginIndex, int endIndex) {
return 2 * (int) Utils.log2(endIndex - beginIndex);
}
private void introsort(T[] array, int beginIndex, int endIndex, int maxdepth) {
if (beginIndex >= endIndex) return;
if (maxdepth == 0) // encounter the worst case
engine.sort(array, beginIndex, endIndex);
else {
int pivotIndex = partition(array, beginIndex, endIndex);
introsort(array, beginIndex, pivotIndex, maxdepth - 1);
introsort(array, pivotIndex + 1, endIndex, maxdepth - 1);
}
}](https://image.slidesharecdn.com/sortdivideconquer-190925013847/85/CS253-Divide-Conquer-Sort-2019-57-320.jpg)
CS253: Divide & Conquer Sort (2019)
- 1. Sort: Divide & Conquer Data Structures and Algorithms Emory University Jinho D. Choi
- 3. QuickSort O(n log n) O(n) O(n log n) O(n log n) O(n log n) O(n log n) O(n log n) O(n log n) O(n log n) O(n log n) O(n )2 O(n log n)
- 4. 2 3 2 7 4 6 8 1 5Merge Sort
- 5. 2 3 2 7 4 6 8 1 5 Merge Sort
- 6. 2 3 2 7 4 6 8 1 5 Merge Sort
- 7. 2 3 2 7 4 6 8 1 5 Merge Sort
- 8. 2 32 7 4 6 8 1 5 Merge Sort
- 9. 2 32 74 6 8 1 5 Merge Sort
- 10. 2 32 74 6 8 1 5 Merge Sort
- 11. 2 32 74 6 8 1 5 Merge Sort
- 12. 2 32 74 6 8 1 5 Merge Sort
- 13. 2 3 2 74 6 8 1 5 Merge Sort
- 14. 2 32 74 6 8 1 5 Merge Sort
- 15. 2 32 74 6 8 1 5 Merge Sort
- 16. 2 32 74 6 8 1 5 Merge Sort
- 18. 2 32 74 6 8 1 5 Merge Sort
- 19. 2 32 74 6 81 5 Merge Sort
- 20. 2 32 74 6 81 5 Merge Sort
- 21. 2 32 74 6 8 1 5 Merge Sort
- 27. 2 32 74 6 8 1 5 Merge Sort
- 28. 2 32 74 6 81 5 Merge Sort
- 29. MergeSort.java public class MergeSort<T extends Comparable<T>> extends AbstractSort<T> { private T[] temp; @Override public void sort(T[] array, int beginIndex, int endIndex) { if (beginIndex + 1 >= endIndex) return; int middleIndex = Utils.getMiddleIndex(beginIndex, endIndex); // sort left partition sort(array, beginIndex, middleIndex); // sort Right partition sort(array, middleIndex, endIndex); // merge partitions merge(array, beginIndex, middleIndex, endIndex); } T[] temp Utils.getMiddleIndex()
- 30. private void copy(T[] array, int beginIndex, int endIndex) { int N = array.length; if (temp == null || temp.length < N) temp = Arrays.copyOf(array, N); else { N = endIndex - beginIndex; System.arraycopy(array, beginIndex, temp, beginIndex, N); } assignments += N; } Arrays.copyOf() System.arraycopy() temp temp
- 31. /** * @param beginIndex the beginning index of the 1st half (inclusive). * @param middleIndex the ending index of the 1st half (exclusive). * @param endIndex the ending index of the 2nd half (exclusive). */ private void merge(T[] array, int beginIndex, int middleIndex, int endIndex) { int fst = beginIndex, snd = middleIndex; copy(array, beginIndex, endIndex); for (int k = beginIndex; k < endIndex; k++) { if (fst >= middleIndex) // no key left in the 1st half assign(array, k, temp[snd++]); else if (snd >= endIndex) // no key left in the 2nd half assign(array, k, temp[fst++]); else if (compareTo(temp, fst, snd) < 0) // 1st key < 2nd key assign(array, k, temp[fst++]); else assign(array, k, temp[snd++]); } }
- 32. Quick Sort 3 3 2 7 4 6 8 1 5
- 33. Quick Sort 3 3 2 7 4 6 8 1 5 Pick a pivot and swap between left and right partitions.
- 34. Quick Sort 3 3 2 7 4 6 8 1 5 Pick a pivot and swap between left and right partitions.
- 35. Quick Sort 3 3 2 7 4 6 8 1 5 Pick a pivot and swap between left and right partitions.
- 36. Quick Sort 3 3 2 7 4 6 8 1 5 Pick a pivot and swap between left and right partitions.
- 37. Quick Sort 3 3 2 7 4 6 8 1 51 7 Pick a pivot and swap between left and right partitions.
- 38. Quick Sort 3 3 2 7 4 6 8 1 51 7 Pick a pivot and swap between left and right partitions.
- 39. Quick Sort 3 3 2 7 4 6 8 1 51 7 Pick a pivot and swap between left and right partitions.
- 40. Quick Sort 3 3 2 7 4 6 8 1 51 71 3 Pick a pivot and swap between left and right partitions.
- 41. Quick Sort 3 3 2 7 4 6 8 1 51 71 1 2 3 6 8 7 5 3 4 Pick a pivot and swap between left and right partitions.
- 42. Quick Sort 3 3 2 7 4 6 8 1 51 71 1 2 3 6 8 7 5 3 4 Pick a pivot and swap between left and right partitions.
- 43. Quick Sort 3 3 2 7 4 6 8 1 51 71 1 2 3 6 8 7 5 3 4 Pick a pivot and swap between left and right partitions.
- 44. Quick Sort 3 3 2 7 4 6 8 1 51 71 1 2 3 6 8 7 5 3 4 Pick a pivot and swap between left and right partitions.
- 45. Quick Sort 3 3 2 7 4 6 8 1 51 71 1 2 3 6 8 7 5 3 4 Pick a pivot and swap between left and right partitions.
- 46. Quick Sort 3 3 2 7 4 6 8 1 51 71 1 2 3 6 8 7 5 3 4 1 2 3 6 8 7 54 Pick a pivot and swap between left and right partitions.
- 47. Quick Sort 3 3 2 7 4 6 8 1 51 71 1 2 3 6 8 7 5 3 4 1 2 3 6 8 7 54 Pick a pivot and swap between left and right partitions.
- 48. Quick Sort 3 3 2 7 4 6 8 1 51 71 1 2 3 6 8 7 5 3 4 1 2 3 6 8 7 54 Pick a pivot and swap between left and right partitions.
- 49. Quick Sort 3 3 2 7 4 6 8 1 51 71 1 2 3 6 8 7 5 3 4 1 2 3 6 8 7 54 5 8 Pick a pivot and swap between left and right partitions.
- 50. Quick Sort 3 3 2 7 4 6 8 1 51 71 1 2 3 6 8 7 5 3 4 1 2 3 6 8 7 54 5 8 Pick a pivot and swap between left and right partitions.
- 51. Quick Sort 3 3 2 7 4 6 8 1 51 71 1 2 3 6 8 7 5 3 4 1 2 3 6 8 7 54 5 8 Pick a pivot and swap between left and right partitions.
- 52. Quick Sort 3 3 2 7 4 6 8 1 51 71 1 2 3 6 8 7 5 3 4 1 2 3 6 8 7 54 5 85 6 Pick a pivot and swap between left and right partitions.
- 53. QuickSort.java @Override public void sort(T[] array, int beginIndex, int endIndex) { // at least one key in the range if (beginIndex >= endIndex) return; int pivotIndex = partition(array, beginIndex, endIndex); // sort left partition sort(array, beginIndex, pivotIndex); // sort right partition sort(array, pivotIndex + 1, endIndex); }
- 54. protected int partition(T[] array, int beginIndex, int endIndex) { int fst = beginIndex, snd = endIndex; while (true) { // Find where endIndex > fst > pivot while (++fst < endIndex && compareTo(array, beginIndex, fst) >= 0); // Find where beginIndex < snd < pivot while (--snd > beginIndex && compareTo(array, beginIndex, snd) <= 0); // pointers crossed if (fst >= snd) break; // exchange swap(array, fst, snd); } // set pivot swap(array, beginIndex, snd); return snd; }
- 55. O(n )2 ∃
- 56. IntroSort.java public class IntroSort<T extends Comparable<T>> extends QuickSort<T> { private AbstractSort<T> engine; public IntroSort(AbstractSort<T> engine, Comparator<T> comparator) { super(comparator); this.engine = engine; } @Override public void resetCounts() { super.resetCounts(); if (engine != null) engine.resetCounts(); } engine resetCount() O(n log n)
- 57. @Override public void sort(T[] array, int beginIndex, int endIndex) { final int maxdepth = getMaxDepth(beginIndex, endIndex); introsort(array, beginIndex, endIndex, maxdepth); comparisons += engine.getComparisonCount(); assignments += engine.getAssignmentCount(); } protected int getMaxDepth(int beginIndex, int endIndex) { return 2 * (int) Utils.log2(endIndex - beginIndex); } private void introsort(T[] array, int beginIndex, int endIndex, int maxdepth) { if (beginIndex >= endIndex) return; if (maxdepth == 0) // encounter the worst case engine.sort(array, beginIndex, endIndex); else { int pivotIndex = partition(array, beginIndex, endIndex); introsort(array, beginIndex, pivotIndex, maxdepth - 1); introsort(array, pivotIndex + 1, endIndex, maxdepth - 1); } }