文章目錄

• • 歸并排序
  • • • 遞歸方法實現
      • 非遞歸方法實現
      • 求數組的小和
  • 快排
  • • • 荷蘭國旗問題（Partition過程）
      • 快排1.0
      • 快排2.0
      • 快排3.0
  • 堆
  • • • 大根堆
      • 堆排序
      • 使用堆排序

歸并排序

遞歸方法實現

public class Code01_MergeSort {// 遞歸方法實現public static void mergeSort1(int[] arr) {if (arr == null || arr.length < 2) {return;}process(arr, 0, arr.length - 1);}// 請把arr[L..R]排有序// l...r N// T(N) = 2 * T(N / 2) + O(N)// O(N * logN)public static void process(int[] arr, int L, int R) {if (L == R) { // base casereturn;}int mid = L + ((R - L) >> 1);process(arr, L, mid);process(arr, mid + 1, R);merge(arr, L, mid, R);}public static void merge(int[] arr, int L, int M, int R) {int[] help = new int[R - L + 1];int i = 0;int p1 = L;int p2 = M + 1;while (p1 <= M && p2 <= R) {help[i++] = arr[p1] <= arr[p2] ? arr[p1++] : arr[p2++];}// 要么p1越界了，要么p2越界了while (p1 <= M) {help[i++] = arr[p1++];}while (p2 <= R) {help[i++] = arr[p2++];}for (i = 0; i < help.length; i++) {arr[L + i] = help[i];}}}

非遞歸方法實現

public static void mergeSort2(int[] arr) {if (arr == null || arr.length < 2) {return;}int N = arr.length;// 步長int mergeSize = 1;while (mergeSize < N) { // log N// 當前左組的，第一個位置int L = 0;while (L < N) {if (mergeSize >= N - L) {break;}int M = L + mergeSize - 1;int R = M + Math.min(mergeSize, N - M - 1);merge(arr, L, M, R);L = R + 1;}// 防止溢出if (mergeSize > N / 2) {break;}mergeSize <<= 1;} }

求數組的小和

在一個數組中，一個數數左邊比它小的數的總和,叫數的小和，所有數的小和累加起來,叫數組的小和

public class Code02_SmallSum {public static int smallSum(int[] arr) {if (arr == null || arr.length < 2) {return 0;}return process(arr, 0, arr.length - 1);}// arr[L..R]既要排好序，也要求小和返回// 所有merge時，產生的小和，累加// 左 排序 merge// 右 排序 merge// mergepublic static int process(int[] arr, int l, int r) {if (l == r) {return 0;}// l < rint mid = l + ((r - l) >> 1);return process(arr, l, mid) + process(arr, mid + 1, r) + merge(arr, l, mid, r);}public static int merge(int[] arr, int L, int m, int r) {int[] help = new int[r - L + 1];int i = 0;int p1 = L;int p2 = m + 1;int res = 0;while (p1 <= m && p2 <= r) {res += arr[p1] < arr[p2] ? (r - p2 + 1) * arr[p1] : 0;help[i++] = arr[p1] < arr[p2] ? arr[p1++] : arr[p2++];}while (p1 <= m) {help[i++] = arr[p1++];}while (p2 <= r) {help[i++] = arr[p2++];}for (i = 0; i < help.length; i++) {arr[L + i] = help[i];}return res;} } public class Code03_ReversePair {public static int reverPairNumber(int[] arr) {if (arr == null || arr.length < 2) {return 0;}return process(arr, 0, arr.length - 1);}// arr[L..R]既要排好序，也要求逆序對數量返回// 所有merge時，產生的逆序對數量，累加，返回// 左 排序 merge并產生逆序對數量// 右 排序 merge并產生逆序對數量public static int process(int[] arr, int l, int r) {if (l == r) {return 0;}// l < rint mid = l + ((r - l) >> 1);return process(arr, l, mid) + process(arr, mid + 1, r) + merge(arr, l, mid, r);}public static int merge(int[] arr, int L, int m, int r) {int[] help = new int[r - L + 1];int i = help.length - 1;int p1 = m;int p2 = r;int res = 0;while (p1 >= L && p2 > m) {res += arr[p1] > arr[p2] ? (p2 - m) : 0;help[i--] = arr[p1] > arr[p2] ? arr[p1--] : arr[p2--];}while (p1 >= L) {help[i--] = arr[p1--];}while (p2 > m) {help[i--] = arr[p2--];}for (i = 0; i < help.length; i++) {arr[L + i] = help[i];}return res;} }

時間復雜度 N*logN

快排

荷蘭國旗問題（Partition過程）

public class Code02_PartitionAndQuickSort {public static void swap(int[] arr, int i, int j) {int tmp = arr[i];arr[i] = arr[j];arr[j] = tmp;}// arr[L..R]上，以arr[R]位置的數做劃分值// <= X > X// <= X Xpublic static int partition(int[] arr, int L, int R) {if (L > R) {return -1;}if (L == R) {return L;}int lessEqual = L - 1;int index = L;while (index < R) {if (arr[index] <= arr[R]) {swap(arr, index, ++lessEqual);}index++;}swap(arr, ++lessEqual, R);return lessEqual;}// arr[L...R] 玩荷蘭國旗問題的劃分，以arr[R]做劃分值// <arr[R] ==arr[R] > arr[R]public static int[] netherlandsFlag(int[] arr, int L, int R) {if (L > R) { // L...R L>Rreturn new int[] { -1, -1 };}if (L == R) {return new int[] { L, R };}int less = L - 1; // < 區 右邊界int more = R; // > 區 左邊界int index = L;while (index < more) { // 當前位置，不能和 >區的左邊界撞上if (arr[index] == arr[R]) {index++;} else if (arr[index] < arr[R]) { // swap(arr, less + 1, index); // less++; // index++; swap(arr, index++, ++less);} else { // >swap(arr, index, --more);}}swap(arr, more, R); // <[R] =[R] >[R]return new int[] { less + 1, more };}}

快排1.0

public static void quickSort1(int[] arr) {if (arr == null || arr.length < 2) {return;}process1(arr, 0, arr.length - 1);}public static void process1(int[] arr, int L, int R) {if (L >= R) {return;}// L..R partition arr[R] [ <=arr[R] arr[R] >arr[R] ]int M = partition(arr, L, R);process1(arr, L, M - 1);process1(arr, M + 1, R);}

快排2.0

public static void quickSort2(int[] arr) {if (arr == null || arr.length < 2) {return;}process2(arr, 0, arr.length - 1);}// arr[L...R] 排有序，快排2.0方式public static void process2(int[] arr, int L, int R) {if (L >= R) {return;}// [ equalArea[0] , equalArea[0]]int[] equalArea = netherlandsFlag(arr, L, R);process2(arr, L, equalArea[0] - 1);process2(arr, equalArea[1] + 1, R);}

快排3.0

public static void quickSort3(int[] arr) {if (arr == null || arr.length < 2) {return;}process3(arr, 0, arr.length - 1);}public static void process3(int[] arr, int L, int R) {if (L >= R) {return;}swap(arr, L + (int) (Math.random() * (R - L + 1)), R);int[] equalArea = netherlandsFlag(arr, L, R);process3(arr, L, equalArea[0] - 1);process3(arr, equalArea[1] + 1, R);}

堆

大根堆

public class Code02_Heap {public static class MyMaxHeap {private int[] heap;private final int limit;private int heapSize;public MyMaxHeap(int limit) {heap = new int[limit];this.limit = limit;heapSize = 0;}public boolean isEmpty() {return heapSize == 0;}public boolean isFull() {return heapSize == limit;}public void push(int value) {if (heapSize == limit) {throw new RuntimeException("heap is full");}heap[heapSize] = value;// value heapSizeheapInsert(heap, heapSize++);}// 用戶此時，讓你返回最大值，并且在大根堆中，把最大值刪掉// 剩下的數，依然保持大根堆組織public int pop() {int ans = heap[0];swap(heap, 0, --heapSize);heapify(heap, 0, heapSize);return ans;}// 新加進來的數，現在停在了index位置，請依次往上移動，// 移動到0位置，或者干不掉自己的父親了，停！private void heapInsert(int[] arr, int index) {// [index] [index-1]/2// index == 0while (arr[index] > arr[(index - 1) / 2]) {swap(arr, index, (index - 1) / 2);index = (index - 1) / 2;}}// 從index位置，往下看，不斷的下沉// 停：較大的孩子都不再比index位置的數大；已經沒孩子了private void heapify(int[] arr, int index, int heapSize) {int left = index * 2 + 1;while (left < heapSize) { // 如果有左孩子，有沒有右孩子，可能有可能沒有！// 把較大孩子的下標，給largestint largest = left + 1 < heapSize && arr[left + 1] > arr[left] ? left + 1 : left;largest = arr[largest] > arr[index] ? largest : index;if (largest == index) {break;}// index和較大孩子，要互換swap(arr, largest, index);index = largest;left = index * 2 + 1;}}private void swap(int[] arr, int i, int j) {int tmp = arr[i];arr[i] = arr[j];arr[j] = tmp;}} }

堆排序

public class Code03_HeapSort {// 堆排序額外空間復雜度O(1)public static void heapSort(int[] arr) {if (arr == null || arr.length < 2) {return;}// O(N*logN) // for (int i = 0; i < arr.length; i++) { // O(N) // heapInsert(arr, i); // O(logN) // }// O(N)for (int i = arr.length - 1; i >= 0; i--) {heapify(arr, i, arr.length);}int heapSize = arr.length;swap(arr, 0, --heapSize);// O(N*logN)while (heapSize > 0) { // O(N)heapify(arr, 0, heapSize); // O(logN)swap(arr, 0, --heapSize); // O(1)}}// arr[index]剛來的數，往上public static void heapInsert(int[] arr, int index) {while (arr[index] > arr[(index - 1) / 2]) {swap(arr, index, (index - 1) / 2);index = (index - 1) / 2;}}// arr[index]位置的數，能否往下移動public static void heapify(int[] arr, int index, int heapSize) {int left = index * 2 + 1; // 左孩子的下標while (left < heapSize) { // 下方還有孩子的時候// 兩個孩子中，誰的值大，把下標給largest// 1）只有左孩子，left -> largest// 2) 同時有左孩子和右孩子，右孩子的值<= 左孩子的值，left -> largest// 3) 同時有左孩子和右孩子并且右孩子的值> 左孩子的值， right -> largestint largest = left + 1 < heapSize && arr[left + 1] > arr[left] ? left + 1 : left;// 父和較大的孩子之間，誰的值大，把下標給largestlargest = arr[largest] > arr[index] ? largest : index;if (largest == index) {break;}swap(arr, largest, index);index = largest;left = index * 2 + 1;}}public static void swap(int[] arr, int i, int j) {int tmp = arr[i];arr[i] = arr[j];arr[j] = tmp;} }

使用堆排序

已知一個幾乎有序的數組。幾乎有序是指，如果把數組排好順序的話，每個元素移動的距離一定不超過k,并且k相對于數組長度來說是比較小的。

// 默認小根堆 PriorityQueue<Integer> heap = new PriorityQueue<>(); public class Code04_SortArrayDistanceLessK {public static void sortedArrDistanceLessK(int[] arr, int k) {if (k == 0) {return;}// 默認小根堆PriorityQueue<Integer> heap = new PriorityQueue<>();int index = 0;// 0...K-1for (; index <= Math.min(arr.length - 1, k - 1); index++) {heap.add(arr[index]);}int i = 0;for (; index < arr.length; i++, index++) {heap.add(arr[index]);arr[i] = heap.poll();}while (!heap.isEmpty()) {arr[i++] = heap.poll();}} }

總結

以上是生活随笔為你收集整理的（归并排序 快排 堆）的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。