排序算法(插入 冒泡 選擇 希爾 增量希爾 堆 快排 快選)

public final class Sort { // 交換排序 冒泡排序 public static <T extends Comparable<? super T>> void bubbleSort(T[] a) { bubbleDownSort(a, 0, a.length); } // 向下冒泡 ####每次從數組末端開始比較相鄰兩元素，把第i小的冒泡到數組的第i個位置。 // i從0一直到N-1從而完成排序。 private static <T extends Comparable<? super T>> void bubbleDownSort(T[] a, int start, int len) { for (int i = start; i < start + len; i++) { for (int j = start + len - 1; j > i; j--) { if (a[j].compareTo(a[j - 1]) < 0) swapReferences(a, j - 1, j); } } } // 向上冒泡 private static <T extends Comparable<? super T>> void bubbleUpSort(T[] a, int start, int len) { for (int i = start + len - 1; i >= start; i--) { for (int j = start; j < i; j++) { if (a[j].compareTo(a[j + 1]) > 0) swapReferences(a, j, j + 1); } } } // 選擇排序 public static <T extends Comparable<? super T>> void selectSort(T[] a) { selectSort(a, 0, a.length); } // 選擇排序相對於冒泡來說，它不是每次發現逆序都交換，而是在找到全局第i小的時候記下該元素位置， // 最後跟第i個元素交換，從而保證數組最終的有序。 // 相對與插入排序來說，選擇排序每次選出的都是全局第i小的，不會調整前i個元素了。 private static <T extends Comparable<? super T>> void selectSort(T[] a, int start, int len) { for (int i = 0; i < len; i++) { int min = i; int j = i + start; for (; j < start + len; j++) if (a[j].compareTo(a[min]) < 0) min = j; swapReferences(a, i, min); } } // 插入排序 該算法在數據規模小的時候十分高效，該算法每次插入 // 第K+1到前K個有序數組中一個合適位置，K從0開始到N-1,從而完成排序 public static <T extends Comparable<? super T>> void insertionSort(T[] a) { int j; for (int p = 1; p < a.length; p++) { T tmp = a[p]; for (j = p; j > 0 && tmp.compareTo(a[j - 1]) < 0; j--) a[j] = a[j - 1]; a[j] = tmp; } } // 常見的shell排序 // Shell排序可以理解爲插入排序的變種，它充分利用了插入排序的兩個特點： // 1）當數據規模小的時候非常高效 // 2）當給定數據已經有序時的時間代價爲O(N) public static <T extends Comparable<? super T>> void shellSort(T[] a) { int j; for (int gap = a.length / 2; gap > 0; gap /= 2) { // 對每個子組做插入排序 for (int i = gap; i < a.length; i++) { T tmp = a[i]; for (j = i; j >= gap && tmp.compareTo(a[j - gap]) < 0; j -= gap) a[j] = a[j - gap]; a[j] = tmp; } } } // 增量序列的shell排序 // Shell排序每次把數據分成若個小塊，來使用插入排序，而且之後在這若個小塊排好序的情況 // 下把它們合成大一點的小塊，繼續使用插入排序，不停的合併小塊，知道最後成一個塊，並使用插入排序。 // 這裏每次分成若干小塊是通過“增量” 來控制的，開始時增量交大，接近N/2,從而使得分割出來接近N/2 // 個小塊，逐漸的減小“增量“最終到減小到1。 // 一直較好的增量序列是2^k-1,2^(k-1)-1,.....7,3,1,這樣可使Shell排序時間複雜度達到O(N^1.5) public static <T extends Comparable<? super T>> void shellDeltaSort(T[] a) { shellDeltaSort(a, 0, a.length); } private static <T extends Comparable<? super T>> void shellDeltaSort(T[] a, int start, int len) { int value = 1; while ((value + 1) * 2 < len) value = (value + 1) * 2 - 1; for (int delta = value; delta >= 1; delta = (delta + 1) / 2 - 1) { for (int i = 0; i < delta; i++) modify_insertt_sort(a, start + i, len - i, delta); } } private final static <T extends Comparable<? super T>> void modify_insertt_sort( T[] a, int from, int len, int delta) { if (len <= 1) return; T tmp = null; for (int i = from + delta; i < from + len; i += delta) { tmp = a[i]; int j; for (j = i; j > from; j -= delta) { if (tmp.compareTo(a[j - delta]) < 0) a[j] = a[j - delta]; else break; } a[j] = tmp; } } // 堆排序 // 堆是一種完全二叉樹，一般使用數組來實現。 // 堆主要有兩種核心操作， // 1）從指定節點向上調整(percUp) // 2）從指定節點向下調整(percDown) // 建堆，以及刪除堆定節點使用percDown,而在插入節點時一般結合兩種操作一起使用。 // 堆排序藉助最大值堆來實現，第i次從堆頂移除最大值放到數組的倒數第i個位置，然後percDown到倒數第i+1個位置,一共執行N此調整，即完成排序。 // 顯然，堆排序也是一種選擇性的排序，每次選擇第i大的元素 public static <T extends Comparable<? super T>> void heapSort(T[] a) { /* 構建MAx堆 */ for (int i = a.length / 2; i >= 0; i--) percDown(a, i, a.length);/* 下濾 */ for (int i = a.length - 1; i > 0; i--) { swapReferences(a, 0, i); percDown(a, 0, i); } } // i節點左孩子位置，注意數組是從0開始 private static int leftChild(int i) { return 2 * i + 1; } // 二叉堆下濾（這裏是Max堆），用於構建Max堆和僞刪除最大值（實際上將最大值至於堆尾） private static <T extends Comparable<? super T>> void percDown(T[] a, int i, int n) { int child; T tmp; for (tmp = a[i]; leftChild(i) < n; i = child) { child = leftChild(i); if (child != n - 1 && a[child].compareTo(a[child + 1]) < 0) child++; if (tmp.compareTo(a[child]) < 0) a[i] = a[child]; else break; } a[i] = tmp; } // 數組兩元素交換值 public static <T> void swapReferences(T[] a, int index1, int index2) { T tmp = a[index1]; a[index1] = a[index2]; a[index2] = tmp; } // 歸併排序 // 每次把待排序列分成兩部分，分別對這兩部分遞歸地用歸併排序， // 完成後把這兩個子部分合併成一個序列。 // 歸併排序藉助一個全局性臨時數組來方便對子序列的歸併，該算法核心在於歸併。 @SuppressWarnings("unchecked") public static <T extends Comparable<? super T>> void mergeSort(T[] a) { T[] tmpArray = (T[]) new Comparable[a.length]; mergeSort(a, tmpArray, 0, a.length - 1); } // 對數組遞歸排序 private static <T extends Comparable<? super T>> void mergeSort(T[] a, T[] tmpArray, int left, int right) { if (left < right) { int center = (left + right) / 2; mergeSort(a, tmpArray, left, center); mergeSort(a, tmpArray, center + 1, right); merge(a, tmpArray, left, center + 1, right); } } // 合併兩個排序好的數組 private static <T extends Comparable<? super T>> void merge(T[] a, T[] tmpArray, int leftPos, int rightPos, int rightEnd) { int leftEnd = rightPos - 1; int tmpPos = leftPos; int numElement = rightEnd - leftPos + 1; while (leftPos <= leftEnd && rightPos <= rightEnd) if (a[leftPos].compareTo(a[rightPos]) <= 0) tmpArray[tmpPos++] = a[leftPos++]; else tmpArray[tmpPos++] = a[rightPos++]; while (leftPos <= leftEnd) tmpArray[tmpPos++] = a[leftPos++]; while (rightPos <= rightEnd) tmpArray[tmpPos++] = a[rightPos++]; for (int i = 0; i < numElement; i++, rightEnd--) a[rightEnd] = tmpArray[rightEnd]; } // 快速排序 public static <T extends Comparable<? super T>> void quickSort(T[] a) { quickSort(a, 0, a.length - 1); } private static final int CUTOFF = 3; private static <T extends Comparable<? super T>> void quickSort(T[] a, int left, int right) { if ((left + CUTOFF) <= right) { T pivot = median3(a, left, right); // 開始分割 int i = left, j = right - 1; for (;;) { while (a[++i].compareTo(pivot) < 0) { } while (a[--j].compareTo(pivot) > 0) { } if (i < j) swapReferences(a, i, j); else break; } swapReferences(a, i, right - 1); quickSort(a, left, i - 1); quickSort(a, i + 1, right); } else insertionSort(a, left, right); } // 對於子數組採用插入排序 private static <T extends Comparable<? super T>> void insertionSort(T[] a, int left, int right) { for (int p = left + 1; p <= right; p++) { T tmp = a[p]; int j; for (j = p; j > left && tmp.compareTo(a[j - 1]) < 0; j--) a[j] = a[j - 1]; a[j] = tmp; } } // 返回數組左、右、中的中值，並對三值比較排序,理論上不排序隻影響排序的效率， // 但是奇怪的是這會產生壞結果 private static <T extends Comparable<? super T>> T median3(T[] a, int left, int right) { int center = (left + right) / 2; if (a[center].compareTo(a[left]) < 0) swapReferences(a, left, center); if (a[right].compareTo(a[left]) < 0) swapReferences(a, left, right); if (a[right].compareTo(a[center]) < 0) swapReferences(a, center, right); swapReferences(a, center, right - 1);// 在right-1位置放置pivot樞紐 return a[right - 1]; } // 快速選擇 public static <T extends Comparable<? super T>> void quickSelect(T[] a, int k) { quickSelect(a, 0, a.length - 1, k); } private static <T extends Comparable<? super T>> void quickSelect(T[] a, int left, int right, int k) { if ((left + CUTOFF) <= right) { T pivot = median3(a, left, right); // 開始分割 int i = left, j = right - 1; for (;;) { while (a[++i].compareTo(pivot) < 0) { } while (a[--j].compareTo(pivot) > 0) { } if (i < j) swapReferences(a, i, j); else break; } swapReferences(a, i, right - 1); if (k <= i) quickSelect(a, left, i - 1, k); else if (k > i + 1) quickSelect(a, i + 1, right, k); } else insertionSort(a, left, right); } private static final int NUM_ITEMS = 1000; private static int theSeed = 1; private static void checkSort(Integer[] a) { for (int i = 0; i < a.length; i++) if (a[i] != i) System.out.println("Error at " + i); System.out.println("Finished checkSort"); } public static void main(String[] args) { Integer[] a = new Integer[NUM_ITEMS]; for (int i = 0; i < a.length; i++) a[i] = i; for (theSeed = 0; theSeed < 5; theSeed++) { Random.permute(a); Sort.insertionSort(a); checkSort(a); Random.permute(a); Sort.bubbleSort(a); checkSort(a); Random.permute(a); Sort.selectSort(a); checkSort(a); Random.permute(a); Sort.shellDeltaSort(a); checkSort(a); Random.permute(a); Sort.heapSort(a); checkSort(a); Random.permute(a); Sort.shellSort(a); checkSort(a); Random.permute(a); Sort.mergeSort(a); checkSort(a); Random.permute(a); Sort.quickSort(a); checkSort(a); Random.permute(a); Sort.quickSelect(a, NUM_ITEMS / 2); System.out.println(a[NUM_ITEMS / 2 - 1] + " " + NUM_ITEMS / 2); } } }

public class Random { private static final int A = 48271; private static final int M = 2147483647; private static final int Q = M / A; private static final int R = M % A; public Random() { this((int) (System.currentTimeMillis() % Integer.MAX_VALUE)); } public Random(int initialValue) { if (initialValue < 0) initialValue += M; state = initialValue; if (state <= 0) state = 1; } public int randomInt() { int tmpState = A * (state % Q) - R * (state / Q); if (tmpState >= 0) state = tmpState; else state = tmpState + M; return state; } public int randomIntWRONG() { return state = (A * state) % M; } public double random0_1() { return (double) randomInt() / M; } public int randomInt(int low, int high) { double partitionSize = (double) M / (high - low + 1); return (int) (randomInt() / partitionSize) + low; } public long randomLong(long low, long high) { long longVal = ((long) randomInt() << 31) + randomInt(); long longM = ((long) M << 31) + M; double partitionSize = (double) longM / (high - low + 1); return (long) (longVal / partitionSize) + low; } // 重排數組 public static final void permute(Object[] a) { Random r = new Random(); for (int i = 0; i < a.length; i++) { Sort.swapReferences(a, i, r.randomInt(0, i)); } } private int state; public static void main(String[] args) { System.out.println(Q); System.out.println(R); Random r = new Random( 1 ); for( int i = 0; i < 20; i++ ) System.out.println( r.randomInt( ) ); } }

參考： Mark Allen Weiss  Data.Structures.and.Algorithm.Analysis.in.Java