【問題描述】

給你一個(gè)整數(shù)數(shù)組 nums，將該數(shù)組升序排列。 示例 1： 輸入：nums = [5,2,3,1] 輸出：[1,2,3,5]

【解答思路】

1.插入排序（熟悉）

每次將一個(gè)數(shù)字插入一個(gè)有序的數(shù)組里，成為一個(gè)長度更長的有序數(shù)組，有限次操作以后，數(shù)組整體有序。

• 優(yōu)化：「將一個(gè)數(shù)字插入一個(gè)有序的數(shù)組」這一步，可以不使用逐步交換，使用先賦值給「臨時(shí)變量」，然后「適當(dāng)?shù)脑亍购笠?#xff0c;空出一個(gè)位置，最后把「臨時(shí)變量」賦值給這個(gè)空位的策略（就是上面那張圖的意思）。編碼的時(shí)候如果不小心，可能會把數(shù)組的值修改，建議多調(diào)試

時(shí)間復(fù)雜度：O(N^2) 空間復(fù)雜度：O(1)

public class Solution {// 插入排序：穩(wěn)定排序，在接近有序的情況下，表現(xiàn)優(yōu)異public int[] sortArray(int[] nums) {int len = nums.length;// 循環(huán)不變量：將 nums[i] 插入到區(qū)間 [0, i) 使之成為有序數(shù)組for (int i = 1; i < len; i++) {// 先暫存這個(gè)元素，然后之前元素逐個(gè)后移，留出空位int temp = nums[i];int j = i;// 注意邊界 j > 0while (j > 0 && nums[j - 1] > temp) {nums[j] = nums[j - 1];j--;}nums[j] = temp;}return nums;} }作者：liweiwei1419 鏈接：https://leetcode-cn.com/problems/sort-an-array/solution/fu-xi-ji-chu-pai-xu-suan-fa-java-by-liweiwei1419/

2.歸并排序（重點(diǎn)）

借助額外空間，合并兩個(gè)有序數(shù)組，得到更長的有序數(shù)組。
時(shí)間復(fù)雜度：O(NlogN) 空間復(fù)雜度：O(N)

• 優(yōu)化 1：在「小區(qū)間」里轉(zhuǎn)向使用「插入排序」，Java 源碼里面也有類似這種操作，「小區(qū)間」的長度是個(gè)超參數(shù)，需要測試決定，我這里參考了 JDK 源碼；
• 優(yōu)化 2： 在「兩個(gè)數(shù)組」本身就是有序的情況下，無需合并；
• 優(yōu)化 3：全程使用一份臨時(shí)數(shù)組進(jìn)行「合并兩個(gè)有序數(shù)組」的操作，避免創(chuàng)建臨時(shí)數(shù)組和銷毀的消耗，避免計(jì)算下標(biāo)偏移量。
• 注意：實(shí)現(xiàn)歸并排序的時(shí)候，要特別注意，不要把這個(gè)算法實(shí)現(xiàn)成非穩(wěn)定排序，區(qū)別就在 <= 和 < ，已在代碼中注明。

public class Solution {// 歸并排序/*** 列表大小等于或小于該大小，將優(yōu)先于 mergeSort 使用插入排序*/private static final int INSERTION_SORT_THRESHOLD = 7;public int[] sortArray(int[] nums) {int len = nums.length;int[] temp = new int[len];mergeSort(nums, 0, len - 1, temp);return nums;}/*** 對數(shù)組 nums 的子區(qū)間 [left, right] 進(jìn)行歸并排序** @param nums* @param left* @param right* @param temp 用于合并兩個(gè)有序數(shù)組的輔助數(shù)組，全局使用一份，避免多次創(chuàng)建和銷毀*/private void mergeSort(int[] nums, int left, int right, int[] temp) {// 小區(qū)間使用插入排序if (right - left <= INSERTION_SORT_THRESHOLD) {insertionSort(nums, left, right);return;}int mid = left + (right - left) / 2;// Java 里有更優(yōu)的寫法，在 left 和 right 都是大整數(shù)時(shí)，即使溢出，結(jié)論依然正確// int mid = (left + right) >>> 1;mergeSort(nums, left, mid, temp);mergeSort(nums, mid + 1, right, temp);// 如果數(shù)組的這個(gè)子區(qū)間本身有序，無需合并if (nums[mid] <= nums[mid + 1]) {return;}mergeOfTwoSortedArray(nums, left, mid, right, temp);}/*** 對數(shù)組 arr 的子區(qū)間 [left, right] 使用插入排序** @param arr 給定數(shù)組* @param left 左邊界，能取到* @param right 右邊界，能取到*/private void insertionSort(int[] arr, int left, int right) {for (int i = left + 1; i <= right; i++) {int temp = arr[i];int j = i;while (j > left && arr[j - 1] > temp) {arr[j] = arr[j - 1];j--;}arr[j] = temp;}}/*** 合并兩個(gè)有序數(shù)組：先把值復(fù)制到臨時(shí)數(shù)組，再合并回去** @param nums* @param left* @param mid [left, mid] 有序，[mid + 1, right] 有序* @param right* @param temp 全局使用的臨時(shí)數(shù)組*/private void mergeOfTwoSortedArray(int[] nums, int left, int mid, int right, int[] temp) {//void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)System.arraycopy(nums, left, temp, left, right + 1 - left);int i = left;int j = mid + 1; //兩條有序序列合并for (int k = left; k <= right; k++) { //left mid +1 //[1,1,2,3] [5,6,7,8] //邊界 左邊遍歷完 右邊還沒開始 右邊持續(xù)插入if (i == mid + 1) {nums[k] = temp[j]; //沒能改變值 j++; // [5,6,7,8] [1,1,2,3] //邊界 右邊遍歷完 左邊還沒開始 左邊持續(xù)插入} else if (j == right + 1) {nums[k] = temp[i];i++;} else if (temp[i] <= temp[j]) {// 注意寫成 < 就丟失了穩(wěn)定性（相同元素原來靠前的排序以后依然靠前）nums[k] = temp[i];i++;} else {// temp[i] > temp[j]nums[k] = temp[j];j++;}}} }作者：liweiwei1419 鏈接：https://leetcode-cn.com/problems/sort-an-array/solution/fu-xi-ji-chu-pai-xu-suan-fa-java-by-liweiwei1419/

3. 快速排序（重點(diǎn)）

快速排序每一次都排定一個(gè)元素（這個(gè)元素呆在了它最終應(yīng)該呆的位置），然后遞歸地去排它左邊的部分和右邊的部分，依次進(jìn)行下去，直到數(shù)組有序；
[外鏈圖片轉(zhuǎn)存失敗,源站可能有防盜鏈機(jī)制,建議將圖片保存下來直接上傳(img-bH18YcEd-1585662450983)(https://upload-images.jianshu.io/upload_images/17025746-9d7d9ff3a2826052.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)]

import java.util.Random;public class Solution {// 快速排序 1：基本快速排序/*** 列表大小等于或小于該大小，將優(yōu)先于 quickSort 使用插入排序*/private static final int INSERTION_SORT_THRESHOLD = 7;private static final Random RANDOM = new Random();public int[] sortArray(int[] nums) {int len = nums.length;quickSort(nums, 0, len - 1);return nums;}private void quickSort(int[] nums, int left, int right) {// 小區(qū)間使用插入排序if (right - left <= INSERTION_SORT_THRESHOLD) {insertionSort(nums, left, right);return;}int pIndex = partition(nums, left, right);quickSort(nums, left, pIndex - 1);quickSort(nums, pIndex + 1, right);}/*** 對數(shù)組 nums 的子區(qū)間 [left, right] 使用插入排序** @param nums 給定數(shù)組* @param left 左邊界，能取到* @param right 右邊界，能取到*/private void insertionSort(int[] nums, int left, int right) {for (int i = left + 1; i <= right; i++) {int temp = nums[i];int j = i;while (j > left && nums[j - 1] > temp) {nums[j] = nums[j - 1];j--;}nums[j] = temp;}}//版本 1：基本快排：把等于切分元素的所有元素分到了數(shù)組的同一側(cè)，可能會造成遞歸樹傾斜；private int partition(int[] nums, int left, int right) { //避免有序數(shù)組 效率低下 隨機(jī)生成一個(gè)整數(shù)，這個(gè)整數(shù)的范圍就是[0,right - left + 1）int randomIndex = RANDOM.nextInt(right - left + 1) + left;swap(nums, left, randomIndex);// 基準(zhǔn)值int pivot = nums[left];int lt = left;// 循環(huán)不變量：// all in [left + 1, lt] < pivot// all in [lt + 1, i) >= pivotfor (int i = left + 1; i <= right; i++) {if (nums[i] < pivot) {lt++;swap(nums, i, lt);}}swap(nums, left, lt);return lt;} //版本 2：雙指針快排：把等于切分元素的所有元素等概率地分到了數(shù)組的兩側(cè)，避免了遞歸樹傾斜，遞歸樹相對平衡；private int partition(int[] nums, int left, int right) {int randomIndex = left + RANDOM.nextInt(right - left + 1);swap(nums, randomIndex, left);int pivot = nums[left];int lt = left + 1;int gt = right;// 循環(huán)不變量：// all in [left + 1, lt) <= pivot// all in (gt, right] >= pivotwhile (true) {while (lt <= right && nums[lt] < pivot) {lt++;}while (gt > left && nums[gt] > pivot) {gt--;}if (lt > gt) {break;}// 細(xì)節(jié)：相等的元素通過交換，等概率分到數(shù)組的兩邊swap(nums, lt, gt);lt++;gt--;}swap(nums, left, gt);return gt;}private void swap(int[] nums, int index1, int index2) {int temp = nums[index1];nums[index1] = nums[index2];nums[index2] = temp;} }作者：liweiwei1419 鏈接：https://leetcode-cn.com/problems/sort-an-array/solution/fu-xi-ji-chu-pai-xu-suan-fa-java-by-liweiwei1419/

版本 3：三指針快排：把等于切分元素的所有元素?cái)D到了數(shù)組的中間，在有很多元素和切分元素相等的情況下，遞歸區(qū)間大大減少
-partition() 合并到quickSort()

private void quickSort(int[] nums, int left, int right) {// 小區(qū)間使用插入排序if (right - left <= INSERTION_SORT_THRESHOLD) {insertionSort(nums, left, right);return;}int randomIndex = left + RANDOM.nextInt(right - left + 1);swap(nums, randomIndex, left);// 循環(huán)不變量：// all in [left + 1, lt] < pivot// all in [lt + 1, i) = pivot// all in [gt, right] > pivotint pivot = nums[left];int lt = left;int gt = right + 1;int i = left + 1;while (i < gt) {if (nums[i] < pivot) {lt++;swap(nums, i, lt);i++;} else if (nums[i] == pivot) {i++;} else {gt--;swap(nums, i, gt);}}swap(nums, left, lt);// 注意這里，大大減少了兩側(cè)分治的區(qū)間quickSort(nums, left, lt - 1);quickSort(nums, gt, right);}作者：liweiwei1419 鏈接：https://leetcode-cn.com/problems/sort-an-array/solution/fu-xi-ji-chu-pai-xu-suan-fa-java-by-liweiwei1419/

4. 堆排序（堆很重要，堆排序根據(jù)個(gè)人情況掌握）

堆排序是選擇排序的優(yōu)化，選擇排序需要在未排定的部分里通過「打擂臺」的方式選出最大的元素（復(fù)雜度 O(N)O(N)），而「堆排序」就把未排定的部分構(gòu)建成一個(gè)「堆」，這樣就能以 O(\log N)O(logN) 的方式選出最大元素；

• 參考《算法 4》堆部分

public class Solution {public int[] sortArray(int[] nums) {int len = nums.length;// 將數(shù)組整理成堆heapify(nums);// 循環(huán)不變量：區(qū)間 [0, i] 堆有序for (int i = len - 1; i >= 1; ) {// 把堆頂元素（當(dāng)前最大）交換到數(shù)組末尾swap(nums, 0, i);// 逐步減少堆有序的部分i--;// 下標(biāo) 0 位置下沉操作，使得區(qū)間 [0, i] 堆有序siftDown(nums, 0, i);}return nums;}/*** 將數(shù)組整理成堆（堆有序）** @param nums*/private void heapify(int[] nums) {int len = nums.length;// 只需要從 i = (len - 1) / 2 這個(gè)位置開始逐層下移for (int i = (len - 1) / 2; i >= 0; i--) {siftDown(nums, i, len - 1);}}/*** @param nums* @param k 當(dāng)前下沉元素的下標(biāo)* @param end [0, end] 是 nums 的有效部分*/private void siftDown(int[] nums, int k, int end) {while (2 * k + 1 <= end) {int j = 2 * k + 1;if (j + 1 <= end && nums[j + 1] > nums[j]) {j++;}if (nums[j] > nums[k]) {swap(nums, j, k);} else {break;}k = j;}}private void swap(int[] nums, int index1, int index2) {int temp = nums[index1];nums[index1] = nums[index2];nums[index2] = temp;} }作者：liweiwei1419 鏈接：https://leetcode-cn.com/problems/sort-an-array/solution/fu-xi-ji-chu-pai-xu-suan-fa-java-by-liweiwei1419/

5. 選擇排序

每一輪選取未排定的部分中最小的部分交換到未排定部分的最開頭，經(jīng)過若干個(gè)步驟，就能排定整個(gè)數(shù)組。即：先選出最小的，再選出第 2 小的，以此類推。
時(shí)間復(fù)雜度：O(N) 空間復(fù)雜度：O(1)

// 選擇排序：每一輪選擇最小元素交換到未排定部分的開頭 import java.util.Arrays;public class Solution {// 選擇排序：每一輪選擇最小元素交換到未排定部分的開頭public int[] sortArray(int[] nums) {int len = nums.length;// 循環(huán)不變量：[0, i) 有序，且該區(qū)間里所有元素就是最終排定的樣子for (int i = 0; i < len - 1; i++) {// 選擇區(qū)間 [i, len - 1] 里最小的元素的索引，交換到下標(biāo) iint minIndex = i;for (int j = i + 1; j < len; j++) {if (nums[j] < nums[minIndex]) {minIndex = j;}}swap(nums, i, minIndex);}return nums;}private void swap(int[] nums, int index1, int index2) {int temp = nums[index1];nums[index1] = nums[index2];nums[index2] = temp;}public static void main(String[] args) {int[] nums = {5, 2, 3, 1};Solution solution = new Solution();int[] res = solution.sortArray(nums);System.out.println(Arrays.toString(res));} }作者：liweiwei1419 鏈接：https://leetcode-cn.com/problems/sort-an-array/solution/fu-xi-ji-chu-pai-xu-suan-fa-java-by-liweiwei1419/

6. 希爾排序（不建議多花時(shí)間了解）

插入排序的優(yōu)化。在插入排序里，如果靠后的數(shù)字較小，它來到前面就得交換多次。「希爾排序」改進(jìn)了這種做法。帶間隔地使用插入排序，直到最后「間隔」為 1 的時(shí)候，就是標(biāo)準(zhǔn)的「插入排序」，此時(shí)數(shù)組里的元素已經(jīng)「幾乎有序」
希爾排序的時(shí)間復(fù)雜度至今還沒有明確的結(jié)論，只有一個(gè)范圍

public class Solution {// 希爾排序public int[] sortArray(int[] nums) {int len = nums.length;int h = 1;// 使用 Knuth 增量序列// 找增量的最大值while (3 * h + 1 < len) {h = 3 * h + 1;}while (h >= 1) {// insertion sortfor (int i = h; i < len; i++) {insertionForDelta(nums, h, i);}h = h / 3;}return nums;}/*** 將 nums[i] 插入到對應(yīng)分組的正確位置上，其實(shí)就是將原來 1 的部分改成 gap** @param nums* @param gap* @param i*/private void insertionForDelta(int[] nums, int gap, int i) {int temp = nums[i];int j = i;// 注意：這里 j >= deta 的原因while (j >= gap && nums[j - gap] > temp) {nums[j] = nums[j - gap];j -= gap;}nums[j] = temp;} }作者：liweiwei1419 鏈接：https://leetcode-cn.com/problems/sort-an-array/solution/fu-xi-ji-chu-pai-xu-suan-fa-java-by-liweiwei1419/

7. 冒泡排序（了解）

外層循環(huán)每一次經(jīng)過兩兩比較，把每一輪未排定部分最大的元素放到了數(shù)組的末尾

public class Solution {// 冒泡排序：超時(shí)public int[] sortArray(int[] nums) {int len = nums.length;for (int i = len - 1; i >= 0; i--) {// 先默認(rèn)數(shù)組是有序的，只要發(fā)生一次交換，就必須進(jìn)行下一輪比較，// 如果在內(nèi)層循環(huán)中，都沒有執(zhí)行一次交換操作，說明此時(shí)數(shù)組已經(jīng)是升序數(shù)組boolean sorted = true;for (int j = 0; j < i; j++) {if (nums[j] > nums[j + 1]) {swap(nums, j, j + 1);sorted = false;}}if (sorted) {break;}}return nums;}private void swap(int[] nums, int index1, int index2) {int temp = nums[index1];nums[index1] = nums[index2];nums[index2] = temp;} }作者：liweiwei1419 鏈接：https://leetcode-cn.com/problems/sort-an-array/solution/fu-xi-ji-chu-pai-xu-suan-fa-java-by-liweiwei1419/

8. 計(jì)數(shù)排序（了解）

每個(gè)出現(xiàn)的數(shù)值都做一個(gè)計(jì)數(shù)，然后根據(jù)計(jì)數(shù)從小到大輸出得到有序數(shù)組。
-保持穩(wěn)定性的做法是：先對計(jì)數(shù)數(shù)組做前綴和，在第 2 步往回賦值的時(shí)候，根據(jù)原始輸入數(shù)組的數(shù)據(jù)從后向前賦值，前綴和數(shù)組保存了每個(gè)元素存放的下標(biāo)信息（這里沒有說得太細(xì)，本來這一點(diǎn)就不重要，也不難理解）。

作者：liweiwei1419
鏈接：https://leetcode-cn.com/problems/sort-an-array/solution/fu-xi-ji-chu-pai-xu-suan-fa-java-by-liweiwei1419/

public class Solution {// 計(jì)數(shù)排序private static final int OFFSET = 50000;public int[] sortArray(int[] nums) {int len = nums.length;// 由于 -50000 <= A[i] <= 50000// 因此"桶" 的大小為 50000 - (-50000) = 10_0000// 并且設(shè)置偏移 OFFSET = 50000，目的是讓每一個(gè)數(shù)都能夠大于等于 0// 這樣就可以作為 count 數(shù)組的下標(biāo)，查詢這個(gè)數(shù)的計(jì)數(shù)int size = 100000;// 計(jì)數(shù)數(shù)組int[] count = new int[size];// 計(jì)算計(jì)數(shù)數(shù)組for (int num : nums) {count[num + OFFSET]++;}// 把 count 數(shù)組變成前綴和數(shù)組for (int i = 1; i < size; i++) {count[i] += count[i - 1];}// 先把原始數(shù)組賦值到一個(gè)臨時(shí)數(shù)組里，然后回寫數(shù)據(jù)int[] temp = new int[len];System.arraycopy(nums, 0, temp, 0, len);// 為了保證穩(wěn)定性，從后向前賦值for (int i = len - 1; i >= 0; i--) {int index = count[temp[i] + OFFSET] - 1;nums[index] = temp[i];count[temp[i] + OFFSET]--;}return nums;} }作者：liweiwei1419 鏈接：https://leetcode-cn.com/problems/sort-an-array/solution/fu-xi-ji-chu-pai-xu-suan-fa-java-by-liweiwei1419/

9. 選擇排序（了解）

• 基于關(guān)鍵字的排序，例如針對數(shù)值排序，個(gè)位、十位、百位就是關(guān)鍵字。針對日期數(shù)據(jù)的排序：年、月、日、時(shí)、分、秒就是關(guān)鍵字
• 「基數(shù)排序」用到了「計(jì)數(shù)排序」

public class Solution {// 基數(shù)排序：低位優(yōu)先private static final int OFFSET = 50000;public int[] sortArray(int[] nums) {int len = nums.length;// 預(yù)處理，讓所有的數(shù)都大于等于 0，這樣才可以使用基數(shù)排序for (int i = 0; i < len; i++) {nums[i] += OFFSET;}// 第 1 步：找出最大的數(shù)字int max = nums[0];for (int num : nums) {if (num > max) {max = num;}}// 第 2 步：計(jì)算出最大的數(shù)字有幾位，這個(gè)數(shù)值決定了我們要將整個(gè)數(shù)組看幾遍int maxLen = getMaxLen(max);// 計(jì)數(shù)排序需要使用的計(jì)數(shù)數(shù)組和臨時(shí)數(shù)組int[] count = new int[10];int[] temp = new int[len];// 表征關(guān)鍵字的量：除數(shù)// 1 表示按照個(gè)位關(guān)鍵字排序// 10 表示按照十位關(guān)鍵字排序// 100 表示按照百位關(guān)鍵字排序// 1000 表示按照千位關(guān)鍵字排序int divisor = 1;// 有幾位數(shù)，外層循環(huán)就得執(zhí)行幾次for (int i = 0; i < maxLen; i++) {// 每一步都使用計(jì)數(shù)排序，保證排序結(jié)果是穩(wěn)定的// 這一步需要額外空間保存結(jié)果集，因此把結(jié)果保存在 temp 中countingSort(nums, temp, divisor, len, count);// 交換 nums 和 temp 的引用，下一輪還是按照 nums 做計(jì)數(shù)排序int[] t = nums;nums = temp;temp = t;// divisor 自增，表示采用低位優(yōu)先的基數(shù)排序divisor *= 10;}int[] res = new int[len];for (int i = 0; i < len; i++) {res[i] = nums[i] - OFFSET;}return res;}private void countingSort(int[] nums, int[] res, int divisor, int len, int[] count) {// 1、計(jì)算計(jì)數(shù)數(shù)組for (int i = 0; i < len; i++) {// 計(jì)算數(shù)位上的數(shù)是幾，先取個(gè)位，再十位、百位int remainder = (nums[i] / divisor) % 10;count[remainder]++;}// 2、變成前綴和數(shù)組for (int i = 1; i < 10; i++) {count[i] += count[i - 1];}// 3、從后向前賦值for (int i = len - 1; i >= 0; i--) {int remainder = (nums[i] / divisor) % 10;int index = count[remainder] - 1;res[index] = nums[i];count[remainder]--;}// 4、count 數(shù)組需要設(shè)置為 0 ，以免干擾下一次排序使用for (int i = 0; i < 10; i++) {count[i] = 0;}}/*** 獲取一個(gè)整數(shù)的最大位數(shù)** @param num* @return*/private int getMaxLen(int num) {int maxLen = 0;while (num > 0) {num /= 10;maxLen++;}return maxLen;} }作者：liweiwei1419 鏈接：https://leetcode-cn.com/problems/sort-an-array/solution/fu-xi-ji-chu-pai-xu-suan-fa-java-by-liweiwei1419/

10. 桶排序（了解）

ublic class Solution {// 桶排序// 1 <= A.length <= 10000// -50000 <= A[i] <= 50000// 10_0000private static final int OFFSET = 50000;public int[] sortArray(int[] nums) {int len = nums.length;// 第 1 步：將數(shù)據(jù)轉(zhuǎn)換為 [0, 10_0000] 區(qū)間里的數(shù)for (int i = 0; i < len; i++) {nums[i] += OFFSET;}// 第 2 步：觀察數(shù)據(jù)，設(shè)置桶的個(gè)數(shù)// 步長：步長如果設(shè)置成 10 會超出內(nèi)存限制int step = 1000;// 桶的個(gè)數(shù)int bucketLen = 100000 / step;int[][] temp = new int[bucketLen + 1][len];int[] next = new int[bucketLen + 1];// 第 3 步：分桶for (int num : nums) {int bucketIndex = num / step;temp[bucketIndex][next[bucketIndex]] = num;next[bucketIndex]++;}// 第 4 步：對于每個(gè)桶執(zhí)行插入排序for (int i = 0; i < bucketLen + 1; i++) {insertionSort(temp[i], next[i] - 1);}// 第 5 步：從桶里依次取出來int[] res = new int[len];int index = 0;for (int i = 0; i < bucketLen + 1; i++) {int curLen = next[i];for (int j = 0; j < curLen; j++) {res[index] = temp[i][j] - OFFSET;index++;}}return res;}private void insertionSort(int[] arr, int endIndex) {for (int i = 1; i <= endIndex; i++) {int temp = arr[i];int j = i;while (j > 0 && arr[j - 1] > temp) {arr[j] = arr[j - 1];j--;}arr[j] = temp;}} }作者：liweiwei1419 鏈接：https://leetcode-cn.com/problems/sort-an-array/solution/fu-xi-ji-chu-pai-xu-suan-fa-java-by-liweiwei1419/

【總結(jié)】

#####1.排序算法總結(jié)
[外鏈圖片轉(zhuǎn)存失敗,源站可能有防盜鏈機(jī)制,建議將圖片保存下來直接上傳(img-1VAMavOi-1585662450986)(https://upload-images.jianshu.io/upload_images/17025746-64aa4a7d0e174744.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)]

1.1 插入排序

• 時(shí)間復(fù)雜度：O(N^2) 空間復(fù)雜度：O(1)
• 優(yōu)點(diǎn) ：在「幾乎有序」的數(shù)組上表現(xiàn)良好，特別地，在「短數(shù)組」上的表現(xiàn)也很好。因?yàn)椤付虜?shù)組」的特點(diǎn)是每個(gè)元素離它最終排定的位置都不會太遠(yuǎn)
• 應(yīng)用：在小區(qū)間內(nèi)執(zhí)行排序任務(wù)的時(shí)候，可以轉(zhuǎn)向使用「插入排序」

1.2 歸并排序

• 時(shí)間復(fù)雜度：O(NlogN) 空間復(fù)雜度：O(N)
  -算法思想：遞歸、分治處理問題的思想在算法領(lǐng)域是非常常見的，通過編寫「歸并排序」學(xué)習(xí)遞歸思想，了解遞歸的細(xì)節(jié)，熟悉分治思想，是相當(dāng)好的學(xué)習(xí)材料。
  -優(yōu)點(diǎn)：「歸并排序」比「快速排序」好的一點(diǎn)是，它借助了額外空間，可以實(shí)現(xiàn)「穩(wěn)定排序」，Java 里對于「對象數(shù)組」的排序任務(wù)，就是使用歸并排序（的升級版 TimSort，在這里就不多做介紹）。

1.3 快排

• 時(shí)間復(fù)雜度：O(NlogN) 空間復(fù)雜度：O(logN)
• 算法思想：分而治之（分治思想），與「歸并排序」不同，「快速排序」在「分」這件事情上不想「歸并排序」無腦地一分為二，而是采用了 partition 的方法，因此就沒有「合」的過程。
  [外鏈圖片轉(zhuǎn)存失敗,源站可能有防盜鏈機(jī)制,建議將圖片保存下來直接上傳(img-BWOPzOP8-1585662450988)(https://upload-images.jianshu.io/upload_images/17025746-ad48df7591da38ac.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)]
  -缺點(diǎn)： 快速排序丟失了穩(wěn)定性，如果需要穩(wěn)定的快速排序，需要具體定義比較函數(shù)，這個(gè)過程叫「穩(wěn)定化」，在這里就不展開了。
• 缺點(diǎn)：（針對特殊測試用例：順序數(shù)組或者逆序數(shù)組）一定要隨機(jī)化選擇切分元素（pivot），否則在輸入數(shù)組是有序數(shù)組或者是逆序數(shù)組的時(shí)候，快速排序會變得非常慢（等同于冒泡排序或者「選擇排序」）；

1.4 堆排序

• 時(shí)間復(fù)雜度：O(NlogN) 空間復(fù)雜度：O(1)
• 堆排序是選擇排序的優(yōu)化，選擇排序需要在未排定的部分里通過「打擂臺」的方式選出最大的元素（復(fù)雜度 O(N)），而「堆排序」就把未排定的部分構(gòu)建成一個(gè)「堆」，這樣就能以 O(logN) 的方式選出最大元素；
• 堆是一種相當(dāng)有意思的數(shù)據(jù)結(jié)構(gòu)，它在很多語言里也被命名為「優(yōu)先隊(duì)列」。它是建立在數(shù)組上的「樹」結(jié)構(gòu)，類似的數(shù)據(jù)結(jié)構(gòu)還有「并查集」「線段樹」等。「優(yōu)先隊(duì)列」是一種特殊的隊(duì)列，按照優(yōu)先級順序出隊(duì)，從這一點(diǎn)上說，與「普通隊(duì)列」無差別。「優(yōu)先隊(duì)列」可以用數(shù)組實(shí)現(xiàn)，也可以用有序數(shù)組實(shí)現(xiàn)，但只要是線性結(jié)構(gòu)，復(fù)雜度就會高，因此，「樹」結(jié)構(gòu)就有優(yōu)勢，「優(yōu)先隊(duì)列」的最好實(shí)現(xiàn)就是「堆」。

1.5 選擇排序

• 時(shí)間復(fù)雜度：O(N^2) 空間復(fù)雜度：O(1)
• 優(yōu)點(diǎn)：交換次數(shù)最少。
• 算法思想 1：貪心算法：每一次決策只看當(dāng)前，當(dāng)前最優(yōu)，則全局最優(yōu)。注意：這種思想不是任何時(shí)候都適用。
• 算法思想 2：減治思想：外層循環(huán)每一次都能排定一個(gè)元素，問題的規(guī)模逐漸減少，直到全部解決，即「大而化小，小而化了」。運(yùn)用「減治思想」很典型的算法就是大名鼎鼎的「二分查找」。

1.6 希爾排序

• 時(shí)間復(fù)雜度：尚不明確

1.7 冒泡排序（了解）

• 時(shí)間復(fù)雜度：O(N^2) 空間復(fù)雜度：O(1)
• 優(yōu)點(diǎn)：「冒泡排序」有個(gè)特點(diǎn)：在遍歷的過程中，提前檢測到數(shù)組是有序的，從而結(jié)束排序，而不像「選擇排序」那樣，即使輸入數(shù)據(jù)是有序的，「選擇排序」依然需要「傻乎乎」地走完所有的流程。

1.8 計(jì)數(shù)排序 1.9 選擇排序 1.10 桶排序

• 時(shí)間復(fù)雜度：O(N) 優(yōu)化
• 特點(diǎn)： 一個(gè)數(shù)該放在哪里，是由這個(gè)數(shù)本身的大小決定的，它不需要經(jīng)過比較。也可以認(rèn)為是哈希的思想：由數(shù)值映射地址。
• 特點(diǎn)： 一定需要額外的空間才能完成排序任務(wù)
• 缺點(diǎn)： 適用場景不多，主要是因?yàn)槭褂眠@三種排序一定要保證輸入數(shù)組的每個(gè)元素都在一個(gè)合理的范圍內(nèi)
• 優(yōu)點(diǎn)：可以實(shí)現(xiàn)成穩(wěn)定排序，無需穩(wěn)定化

2.代碼規(guī)范

2.1 循環(huán)不變量 （快排）
-保持「循環(huán)不變量」，即定義的變量在循環(huán)開始前、循環(huán)過程中、循環(huán)結(jié)束以后，都保持不變的性質(zhì)，這個(gè)性質(zhì)是人為根據(jù)問題特點(diǎn)定義的。
循環(huán)不變量」是證明算法有效性的基礎(chǔ)，更是寫對代碼的保證，遵守循環(huán)不變量，是不是該寫等于號，先交換還是先 ++ ，就會特別清楚，絕對不會寫錯(cuò)，將遵守的「循環(huán)不變量」作為注釋寫在代碼中。
2.2 《算法 4》代碼風(fēng)格不推薦

• 代碼是寫給人看的，應(yīng)該盡量避免代碼個(gè)人風(fēng)格化，采用統(tǒng)一規(guī)范的寫法，保證易讀性，可擴(kuò)展性。
  [外鏈圖片轉(zhuǎn)存失敗,源站可能有防盜鏈機(jī)制,建議將圖片保存下來直接上傳(img-ntkuZXCs-1585662450990)(https://upload-images.jianshu.io/upload_images/17025746-5aba0141df398096.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)]
  2.3 變量名稱優(yōu)化
• lt 是 less than 的縮寫，表示（嚴(yán)格）小于；
• gt 是 greater than 的縮寫，表示（嚴(yán)格）大于；
• le 是 less than or equal 的縮寫，表示小于等于（本代碼沒有用到）；
• ge 是 greater than or equal 的縮寫，表示大于等于（本代碼沒有用到）。

3.排序入門成功 筆試面試不慌

public int[] sortArray(int[] nums) {Arrays.sort(nums);return nums;}

安利網(wǎng)站：

算法動態(tài)演示

參考鏈接：https://leetcode-cn.com/problems/sort-an-array/solution/fu-xi-ji-chu-pai-xu-suan-fa-java-by-liweiwei1419/

總結(jié)

以上是生活随笔為你收集整理的[Leetcode][JAVA][第912题][排序算法]的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯(cuò)，歡迎將生活随笔推薦給好友。