參考鏈接
本文只給出算法的Java實現版本,具體原理參考:八大排序算法。
公用代碼
下面的swap()
函數,是排序算法中經常用到的,單獨貼出來。
public void swap(int[] a, int i, int j) { int tmp = a[i]; a[i] = a[j]; a[j] = tmp; }
冒泡排序
/** * 冒泡排序:每次循環,將最後一個位置排序好 * 算法改進:加一個標誌位,記錄每趟排序最後一個進行交換的位置,下一次只需掃描到pos * @param a */ public void bubbleSort(int[] a) { if (a == null) { return; } int right = a.length - 1; while (right > 0) { int pos = 0; for (int start = 0; start < right; start++) { if (a[start] > a[start + 1]) { swap(a, start, start + 1); pos = start; } } right = pos; } }
直接插入排序
將一個記錄插入到已排序好的有序表中,從而得到一個新,記錄數增1的有序表。即:先將序列的第1個記錄看成是一個有序的子序列,然後從第2個記錄逐個進行插入,直至整個序列有序爲止。
public void insertSort(int[] a) { for (int right = 1; right < a.length; right++) { if (a[right] < a[right - 1]) { int tmp = a[right]; // 保存臨時變量 int left = right - 1; a[right] = a[right - 1]; // 先後移一個位置 for (; left >= 0 && tmp < a[left]; left--) { a[left + 1] = a[left]; } a[left + 1] = tmp;// 插入到正確位置 } } }
簡單選擇排序
- 選出最小的元素,與數組第一個位置交換
- 選出第i小的元素,與數組第i個位置交換
- 直到第n-1個元素,與第n個元素比較爲止
/** * 選擇排序-簡單選擇排序 * 基本思想:在一組要排序的數中,選取最小的與第一個位置交換 */ public void selectSort(int[] a) { for(int start = 0; start < a.length; start++) { int key = selectMinKey(a, start); swap(a, key, start); } } private int selectMinKey(int[] a, int start) { int key = start; for(int i = start; i < a.length; i++) { key = a[key] > a[i] ? i : key; } return key; }
快速排序
public void quickSort(int[] a) { quickSort0(a, 0, a.length - 1); } private void quickSort0(int[] a, int low, int high) { if (low < high) { int pos = partition(a, low, high); quickSort0(a, low, pos - 1); quickSort0(a, pos + 1, high); } } private int partition(int[] a, int low, int high) { int privotKey = a[low]; while (low < high) { while (low < high && a[high] >= privotKey) { high--; } swap(a, low, high); while (low < high && a[low] <= privotKey) { low++; } swap(a, low, high); } return low; }
歸併排序
public void mergeSort(int[] a) { mergeSort0(a, 0, a.length - 1); } private void mergeSort0(int[] a, int left, int right) { if (left < right) { int mid = (left + right) / 2; mergeSort0(a, left, mid); mergeSort0(a, mid + 1, right); merge(a, left, mid, right); } } private void merge(int[] a, int start1, int mid, int right) { int[] tmp = new int[a.length]; int k = start1; // tmp的初始下標 int start = start1; // 記錄初始位置 int start2 = mid + 1; // 第2個數組的起始位置 for(; start1 <= mid && start2 <= right; k++) { tmp[k] = a[start1] < a[start2] ? a[start1++] : a[start2++]; } // 左邊剩餘的合併 while (start1 <= mid) { tmp[k++] = a[start1++]; } // 右邊剩餘的合併 while (start2 <= right) { tmp[k++] = a[start2++]; } // 複製數組 while (start <= right) { a[start] = tmp[start]; start++; } }
堆排序
public void heapSort(int[] a) { buildingHeap(a, a.length); for (int i = a.length - 1; i > 0; i--) { swap(a, i, 0); adjustHeap(a, 0, i); System.out.println(Arrays.toString(a)); } } /** * 選擇排序-堆排序 * * 若以一維數組存儲一個堆,則堆對應一個完全二叉樹,且所有非葉結點的值,不大於其子女的值 * 堆頂元素是最小的(小頂堆) * * * 已知a[s...m]除了a[s]外均滿足堆的定義 調整a[s],使之成爲大頂堆,將第s個結點爲根的子樹篩選 * * a:待調整的堆數組 s:待調整的數組元素的位置 length:數組長度 */ private void adjustHeap(int[] a, int s, int length) { int tmp = a[s]; int child = 2 * s + 1; // 左孩子結點位置 while (child < length) { // 如果有右孩子,同時右孩子值 > 左孩子值 if (child + 1 < length && a[child] < a[child + 1]) child++; if (a[s] < a[child]) { // 較大的子結點>父節點 a[s] = a[child]; // 替換父節點 s = child; // 重新設置,待調整的下一個結點位置 child = 2 * s + 1; } else break; a[s] = tmp; // 交換 } } /** * 初始堆進行調整 將a[0...length-1]建成堆 * 調整完後,第一個元素是序列最小的元素 */ private void buildingHeap(int[] a, int length) { // 最有一個有孩子結點的位置是 i = (length - 1) / 2 for (int i = (length - 1) / 2; i >= 0; i--) { adjustHeap(a, i, length); } }
測試用例
@Test public void testHeapSort() { int[] a = new int[] { 4, 11, 5, 8, 1, 9, 2 }; heapSort(a); System.out.println(Arrays.toString(a)); }
圖解
buildingHeap 後,形成了大頂堆。
已經找到最大元素,與數組最後一個位置交換。
交換之後的二叉樹並不平衡,需要調整。