十大經典排序算法總結（動圖演示）

算法分類

• 十大常見排序算法可分為兩大類：
  • 比較排序算法：通過比較來決定元素的位置，由于時間復雜度不能突破O(nlogn)，因此也稱為非線性時間比較類排序
  • 非比較類型排序：不通過比較來決定元素的相對次序，他可以突破基于比較排序的時間下限，以線性時間運行，因此也稱為線性時間非比較類排序
    

相關概念

• 穩定排序：如果原數據中a在b之前，而且a=b，排序后a任然在b之前
• 不穩定排序：如果原數據中a在b之前，而且a=b，排序后a在b之后
• 時間復雜度：對排序數據的總的操作次數，反映當n變化時候，操作次數呈現出什么規律
• 空間復雜度：指算法在計算機內執行時所需要的存儲空間的度量，他也是數據規模n的函數。

冒泡排序

• 冒泡排序是一種簡單的排序算法，重復遍歷需要排序的數列，一次比較兩個元素，如果他們順序錯誤就把他們交換過來。持續遍歷交換直到排序完成。

算法分析

• 比較相鄰元素，如果前一個比后一個大，就交換他們
• 對每一對相鄰元素做同樣的工作，從開始第一對到結尾的最后一對，這樣在最后的元素應該就變成了最大值
• 針對所有元素重復以上步驟，除了最后一個
• 重復1~3步驟直到完成排序

動圖展示

代碼實現：

public class BubbleSort {public static int[] getArrayData(){int[] arrayData = new int[20];Random random = new Random();for (int i = 0; i < 20; i++) {arrayData[i] = random.nextInt(1000);}return arrayData;}/*** 時間復雜度 O(n^2) 空間復雜度O(1)* 從小到大排序冒泡排序* */public static int[] bubbleSort(int[] arrayData){if(null == arrayData || arrayData.length <= 1){return arrayData;}for (int i = 0; i < arrayData.length; i++) {for (int j = 0; j < arrayData.length - 1; j++) {if(arrayData[j] > arrayData[i]){int temp = arrayData[j];arrayData[j] = arrayData[i];arrayData[i] = temp;}}}return arrayData;}public static void main(String[] args) {int[] arrayData = bubbleSort(getArrayData());for (int i = 0; i < arrayData.length; i++) {System.out.println(arrayData[i]);}} }

選擇排序

• 選擇排序（selection sort）是一種簡單的比較容易理解的算法，工作原理：在未排序的數列中找到最小的一個，將他的位置所在數據與數列首位交換，接著從生下未排序的元素中繼續找最小的元素和第二個交換，直到數列末尾。

算法分析

• n個數據的數列排序經過n-1次查找可以完成排序
• 第i（0 <= i < n）次排序，默認數據第i個數據是最小的數據，從第i個數據開始遍歷數列
• 如果發現有比第i個數據更小的數據 j，記錄位置 j，將最小的數據更換成第j個，持續遍歷查找到 第i個數據后最小的數據 j
• 將數列中第j個數據與第 i個數據進行交換
• 同樣，的步驟對 第 i+1 個數據進行處理，直到第n-1 個數據。

動圖演示

代碼實現

public class BubbleSort {public static int[] getArrayData(){int[] arrayData = new int[20];Random random = new Random();for (int i = 0; i < 20; i++) {arrayData[i] = random.nextInt(1000);}return arrayData;}/*** 時間復雜度 O(n^2) 空間復雜度O(1)* 從小到大選擇排序* */public static int[] selectionSort(int[] arrayData){if(null == arrayData || arrayData.length <=1){return arrayData;}for (int i = 0; i < arrayData.length; i++) {int last = arrayData[i];int position = i;for (int j = i+1; j < arrayData.length; j++) {if(last > arrayData[j]){last = arrayData[j];position = j;}}int temp = arrayData[i];arrayData[i] = arrayData[position];arrayData[position] = temp;}return arrayData;}public static void main(String[] args) {int[] arrayData = selectionSort(getArrayData());for (int i = 0; i < arrayData.length; i++) {System.out.println(arrayData[i]);}} }

特點

• 選擇排序是最穩定的排序算法之一，因為無論什么數據進去時間復雜度都是O(n^2)。所以用它的時候數據規模越小越好。唯一的好處是不額外占用內存，空間復雜度O(1)，理論上選擇排序可能也是憑虛最容易理解的排序算法。

插入排序

• 插入排序算法工作原理是通過構建有序序列，對于未排序的數據，在一家排序序列中從后向前掃描，找到相應位置插入。也可以逐步移動到對應位置

算法分析

• 從第一個元素開始，此元素我們看成已經有序的，我們認為第一二個數據已經有序
• 取下一個元素，此處是第三元素，和之前有序列中的數據從后先前比較
• 如果已排序的改元素大于新元素，將這個元素移動到下一個位置
• 重復上這個步驟，直到找到一家排序的元素小于或者等于新元素的位置
• 建新元素插入到該位置的后面的空位上（上一步的數據交換已經完成這部操作）
• 重復以上2~5 步驟

動圖演示

代碼實現

public class BubbleSort {public static int[] getArrayData(){int[] arrayData = new int[20];Random random = new Random();for (int i = 0; i < 20; i++) {arrayData[i] = random.nextInt(1000);}return arrayData;}/*** 時間復雜度 O(n^2) 空間復雜度O(1)* 從小到大插入排序* */public static int[] insertionSort(int[] arrayData){if(null == arrayData || arrayData.length <= 1){return arrayData;}for (int i = 1; i < arrayData.length; i++) {for (int j = i; j > 0; j--) {if(arrayData[j-1] > arrayData[j]){int temp = arrayData[j-1];arrayData[j-1] = arrayData[j];arrayData[j] = temp;}}}return arrayData;}public static void main(String[] args) {int[] arrayData = insertionSort(getArrayData());for (int i = 0; i < arrayData.length; i++) {System.out.println(arrayData[i]);}} }

希爾排序

• 1959年shell發明的，第一個突破O(n^2)的一個排序算法，是簡單插入排序的改進版本。他原插入排序不同在于，會分組進行比較，并且優先比較距離較遠的元素。希爾排序又稱為縮小增量排序。

算法分析

• 先將整個待排序的記錄序列分割成若干子序列，并分別對子序列進行直接插入排序，具體分析如下
• 選擇一個增量規則，將整個序列分成t1,t2，t3…tk，其中ti > tj，tk=1.
• 按照增量個數k，對序列進行k次遍歷排序
• 每次排序，更具對應的增量ti，將待排序的序列分隔成若干個長度的m的子序列
• 分別對每個子序列進行直接插入排序，僅僅存在增量是1 的時候，整個序列作為一個整體子序列來處理，表長度就等于整個序列長度
• EX：此處比較繞，舉個案例，長度為10的數列
  • 分組方法每次對半分組，第一次10/2 = 5 組，分別為：（0，5），（1，6），（2，7），（3，8），（4，9）
  • 接著第二次在對半分5/2 = 2組，分別為：（0，2，4，6，8），（1，3，5，7，9）
  • 第三次繼續對半分2/2=1組：0，1，2，3，4，5，6，7，8，9
  • 每一次分組都將對各個組進行選擇插入排序，得到最終結果

動圖說明

代碼實現

public class BubbleSort {public static int[] getArrayData(){int[] arrayData = new int[20];Random random = new Random();for (int i = 0; i < 20; i++) {arrayData[i] = random.nextInt(1000);}return arrayData;}/*** 時間復雜度評價 O(nlog2n) 空間復雜度O(1)* 從小到大希爾排序* */public static int[] shellSort(int[] arrayData){if(null == arrayData || arrayData.length <= 1){return arrayData;}for (int gap = arrayData.length/2; gap > 0 ; ; gap/=2) {for (int i =gap; i<arrayData.length; i++){//此處i 在分組的第一組數據的最后一個數據 i+1 第二組，i+2第三組，依次類推//此處j 從該分組數據的最后一個數據向前遍歷，遇到更大的值就交換// （用gap來區分分組，與插入排序一模一樣，只不過簡單插入排序間隔是i--，此處是i-=gap）for(int j = i;j-gap>=0;j-=gap){if(arrayData[j-gap] > arrayData[j]){int temp = arrayData[j];arrayData[j] = arrayData[j-gap];arrayData[j-gap] = temp;}}}}return arrayData;}public static void main(String[] args) {int[] arrayData = shellSort(getArrayData());for (int i = 0; i < arrayData.length; i++) {System.out.println(arrayData[i]);}} }

時間復雜度說明

• 希爾排序的核心在于間隔序列的設定，即可以提前設定好間隔序列，也可以動態定義間隔序列。
• 希爾排序執行時間依賴于對得到的序列的排序，取決于需要分組的多少,所以時間復雜度情況如下：
  • 最好情況：序列是正序排序，這種情況，需要進行的比較次數是n-1次。后移賦值操作為0 次，即O（n）
  • 最壞情況：O（nlog2n）
  • 平均時間復雜度：O（nlog2n）

歸并排序

• 歸并排序是建立在歸并操作的基礎上的一種有效的排序算法。算法核心是采用分治思想（Divide and conquer）的一個非常典型的應用。將已經有的子序列排序后合并，得到完全有序的序列，即先使每個子序列有序，在使子序列段間有序。若兩個有序表合并成一個有序表，稱為2-路歸并

算法分析

• 吧長度為n的輸入序列分為兩個長度為n/2的子序列
• 對每個子序列分表采用歸并排序（遞歸）直到序列長度足夠小（>2）
• 將兩個子序列排序好，并將兩個子序列合并成一個最終序列

動圖演示

代碼實現

public class BubbleSort {public static int[] getArrayData(int size) {int[] arrayData = new int[size];Random random = new Random();for (int i = 0; i < size; i++) {arrayData[i] = random.nextInt(1000);}return arrayData;}/*** 時間復雜度O(nlogn) 空間復雜度O(n)* 從小到大，歸并排序*/public static int[] mergeSort(int[] arrayData) {if (null == arrayData || arrayData.length <= 1) {return arrayData;}//此處優化20210309if (arrayData.length <= 2) {return arrayData;}int middle = arrayData.length / 2;int[] left = Arrays.copyOfRange(arrayData, 0, middle);int[] right = Arrays.copyOfRange(arrayData, middle, arrayData.length);return merge(mergeSort(left), mergeSort(right));}public static int[] merge(int[] left, int[] right) {int[] result = new int[left.length + right.length];//此處優化，不用冒泡排，基礎情況只會存在2個元素，無需冒泡排序直接交換if (left.length == 2) {if (left[0] > left[1]) {int temp = left[0];left[0] = left[1];left[1] = temp;}}if (right.length == 2) {if (right[0] > right[1]) {int temp = right[0];right[0] = right[1];right[1] = temp;}}int leftPosition = left.length - 1;int rightPosition = right.length - 1;int resultPosition = result.length - 1;while (resultPosition >= 0) {if (rightPosition < 0 || (leftPosition >= 0 && left[leftPosition] > right[rightPosition])) {result[resultPosition--] = left[leftPosition--];} else {result[resultPosition--] = right[rightPosition--];}}return result;}public static void main(String[] args) {int[] arrayData = mergeSort(getArrayData(20));for (int i = 0; i < arrayData.length; i++) {System.out.println(arrayData[i]);}} }

算法總結

• 歸并排序是一種穩定的排序。和選擇排序一樣，歸并排序性能不受輸入數據的影響，但是表現比選擇排序要好得多，因為始終都是O(nlogn)的時間復雜度。代價是需要額外的內存空間。

快速排序

• 快速排序基本思想：通過一次排序將待排序的記錄隔開成兩個數列，數列中前部分數據比基準值小（或大），數列中后部分數據比基準值大（或小），則接下來繼續對這兩部分數列進行快速排序，直到整個序列有序。

算法分析

• 快速排序使用分治法吧一個數列（list）分為兩個字數列（subList）。具體分析如下
• 從數列中跳出一個元素，稱為基準值privot，我們默認每次將數列第一個數據作為基準值
• 此處用挖坑填寫數據的方式將數據中小于 privot的數據放到數列左邊，將數據大于privot的數據放到基準值右邊，過程如下
  • 記起始，結束為止分別為left，right，基準值privot=left
  • 從right向前遍歷找小于基準值的數據放到當前left位置
  • 從left向后遍歷找大于基準值的數據，放到right位置，
  • 當left == right時候，將之前的privot數據放入left位置， 記當前位置temp
• 將原數量分為兩個子數列：left~ temp-1，temp+1~right
• 遞歸得到有序數列

動圖演示

代碼實現

public class BubbleSort {public static int[] getArrayData(int size) {int[] arrayData = new int[size];Random random = new Random();for (int i = 0; i < size; i++) {arrayData[i] = random.nextInt(1000);}return arrayData;}/*** 時間復雜度平均O(nlog2^n) 空間復雜度O(nlog2^n)* 從小到大快速排序* */public static int[] quickSort(int[] arrayData) {if (null == arrayData || arrayData.length <= 1) {return arrayData;}quickSort(arrayData, 0, arrayData.length - 1);return arrayData;}public static void quickSort(int[] arrayData, int left, int right){if(left < right){int temp = swap2(arrayData, left, right);quickSort(arrayData, left, temp -1);quickSort(arrayData, temp +1, right);}}public static int swap2(int[] arrayData, int left, int right) {if(left < right){int positionData = arrayData[left];while (left < right){//從后先前找一個小于基準值positionData的數據while (right > left && arrayData[right] > positionData){right --;}if(left < right){arrayData[left] = arrayData[right];left ++;}//從前向后找一個大于基準值的數據while (left < right && arrayData[left] < positionData){left ++;}if(left < right){arrayData[right] = arrayData[left];right --;}}arrayData[left] = positionData;}return left;}public static void main(String[] args) {int[] beginArrayData = getArrayData(10);int[] arrayData = quickSort(beginArrayData);for (int i = 0; i < arrayData.length; i++) {System.out.println(arrayData[i]);}} }

計數排序

• 計數排序不是基于比較的排序算法，核心在于輸入的數據轉換為鍵值存儲在額外的空間中，作為線性時間復雜度的排序，計數排序要求輸入的數據必須是有明確的范圍的整數。

算法分析

• 找出數列中最大元素，最小元素
• 統計數組中最每個元素值的個數，并且存儲到數組C的第i項（例如21這個數字出現兩次，則C[21] = 2）
• 記錄原數組初始位置position=0，從頭遍歷新數組C
• 當C元素為n ，將C下標存儲到position位置，position向前增加一位，重復執行n次
• 得到最終有序數列

動圖演示

public class BubbleSort {public static int[] getArrayData(int size) {int[] arrayData = new int[size];Random random = new Random();for (int i = 0; i < size; i++) {int temp = random.nextInt(100);if(temp > 100){arrayData[i] = temp;}else {int value = temp - 2*temp;arrayData[i] = value;}}return arrayData;}/*** 時間復雜度O(n+k), 空間復雜度O(n+k)* @author: liaojiamin* 從小到大計數排序*/public static int[] countSortCompaNegative(int[] arrayData) {if (null == arrayData || arrayData.length <= 1) {return arrayData;}int minValue = arrayData[0];int maxvalue = arrayData[0];for (int i = 0; i < arrayData.length; i++) {if (arrayData[i] > maxvalue) {maxvalue = arrayData[i];}if (arrayData[i] < minValue) {minValue = arrayData[i];}}//全正數情況if (minValue >= 0) {return countSort(arrayData, maxvalue, false);}//全負數情況if (maxvalue <= 0) {return countSort(arrayData, Math.abs(minValue), true);}//正負兼有情況return countSortAll(arrayData, minValue, maxvalue);}public static int[] countSortAll(int[] arrayData, int minValue, int maxvalue){int[] nagative = new int[Math.abs(minValue) + 1];int[] positive = new int[maxvalue + 1];for (int i = 0; i < arrayData.length; i++) {if (arrayData[i] > 0) {int temp = positive[arrayData[i]];temp += 1;positive[arrayData[i]] = temp;} else {int nagativePosition = Math.abs(arrayData[i]);int temp = nagative[nagativePosition];temp += 1;nagative[nagativePosition] = temp;}}int position = 0;for (int i = nagative.length - 1; i >= 0; i--) {if(nagative[i] > 0){for (int j = 0; j < nagative[i]; j++) {int value = i-2*i;arrayData[position++] = value;}}}for (int i = 0; i < positive.length; i++) {if(positive[i] > 0){for (int j = 0; j < positive[i]; j++) {arrayData[position ++] = i;}}}return arrayData;}public static int[] countSort(int[] arrayData, int maxValue, boolean isNegative) {if (null == arrayData || arrayData.length <= 1) {return arrayData;}int[] countArray = new int[maxValue + 1];for (int i = 0; i < arrayData.length; i++) {int value = Math.abs(arrayData[i]);int temp = countArray[value];temp += 1;countArray[value] = temp;}int position = 0;if (isNegative) {position = arrayData.length - 1;} else {position = 0;}for (int i = 0; i < countArray.length; i++) {if (countArray[i] > 0) {for (int j = 0; j < countArray[i]; j++) {if (isNegative) {//負數int value = i-2*i;arrayData[position--] = value;} else {arrayData[position++] = i;}}}}return arrayData;}public static void main(String[] args) {int[] beginArrayData = getArrayData(20);int[] arrayData = countSortCompaNegative(beginArrayData);for (int i = 0; i < arrayData.length; i++) {System.out.println(arrayData[i]);}} }

算法分析

• 以上算法分析以及 動圖演示僅針對于全正數情況，以此類推，全負數，正負兼有的情況如代碼實現，思想一致，歸類的時候有一點不同
• 計數排序是一個穩定的排序算法，當輸入的元素是n個0 到k 之間的證書時候，時間復雜度是O(n+k)，空間復雜度也是O(n+k)，排序速度比任何比較排序都要快。當k不是很大并且序列比較集中時候，計數排序是一個很有效的排序算法。

桶排序

• 桶排序是計數排序的升級版本，利用函數映射相關的思想，高效性取決于映射函數的確定，桶排序的工作原：假設需排序的數據基于均勻分配的一個區間的數據，將數據通過固定的算法分配到有限數量的桶中，每個桶在分別排序

算法分析

• 設置一個定量的數組當做空桶
• 遍歷需待排序數列，得到min， max，通過（max- min）/bucksize +1,得到每個桶最多可能會容納的個數（與你選取的hash算法有關系）
• 遍歷待排序隊列，將數據公共上面的算法一個一個放入桶中
• 對每個不是空桶中的數據信息排序
• 從不是空的桶中將數據按順序取出，得到最終排序數據。

圖片演示

代碼實現

public static int[] getArrayData(int size) {int[] arrayData = new int[size];Random random = new Random();for (int i = 0; i < size; i++) {int temp = random.nextInt(100);if(temp > 0){arrayData[i] = temp;}else {int value = temp - 2*temp;arrayData[i] = value;}}return arrayData;} /*** 時間復雜度O(n), 空間復雜度O(n+k)* 從小到大通排序* @author: liaojiamin* @date: 18:09 2020/11/16*/public static int[] bucketSort(int[] arrayData){if (null == arrayData || arrayData.length <= 1) {return arrayData;}int pos = arrayData.length;//默認十個桶int bucketSize = 10;if(pos <= 1){return arrayData;}int min = arrayData[0];int max = arrayData[0];for (int i = 0; i < pos; i++) {if(arrayData[i] < min){min = arrayData[i];}if(arrayData[i] > max){max = arrayData[i];}}int bucketCount = (max - min)/bucketSize + 1;//二維數組以為標識桶， 二維存放數字，最差情況所有數字在統一個桶中int[][] bucket = new int[bucketCount][pos];//統計最終桶中數據個數，做游標position作用，指定改桶下一個數據存放位置int[] index = new int[bucketCount];for (int i = 0; i < pos; i++) {int num = (arrayData[i] - min)/bucketSize ;//將 第num個桶的第index[index] 個數賦值bucket[num][index[num]++] = arrayData[i];}int position = 0;for (int i = 0; i < bucket.length; i++) {//對每一個進行插入排序insertionSort(bucket[i]);for (int j = bucket[i].length - index[i]; j < bucket[i].length; j++) {arrayData[position++] = bucket[i][j];}}return arrayData;} /*** 時間復雜度 O(n^2) 空間復雜度O(1)* 從小到大插入排序*/public static int[] insertionSort(int[] arrayData) {if (null == arrayData || arrayData.length <= 1) {return arrayData;}for (int i = 1; i < arrayData.length; i++) {for (int j = i; j > 0; j--) {if (arrayData[j - 1] > arrayData[j]) {int temp = arrayData[j - 1];arrayData[j - 1] = arrayData[j];arrayData[j] = temp;}}}return arrayData;}public static void main(String[] args) {int[] beginArrayData = getArrayData(10);int[] arrayData = bucketSort(beginArrayData);for (int i = 0; i < arrayData.length; i++) {System.out.println(arrayData[i]);}}

算法分析

• 桶排序最好情況下線性時間O(n)，桶排序的時間復雜度取決于對各個桶之間數據進行排序的時間復雜度，因為其他部分時間福再度就是O(n)，很顯然，桶劃分的越小，各個桶之間的數據越少，排序所用的時間也就越少，但相應的空間消耗就越大。

基數排序

• 基數排序按照低位先排序，然后手機，接著高位在排序，在收集，依次類推，直到最高位。有時候有些屬性是有優先順序的，先按低優先級排序，最后的次序就是最高優先級高的在前面，高優先級相同的低優先級高的在前面。

算法分析

• 去的數組中最大數，并取得改數字的位數
• 申請新存儲空間，二維數組，一維當做桶的位置，二維存儲改桶的數字
• 遍歷目標數列，最低位個位情況：將每個數字通過 取模，再取余得到他所在低位桶位置 （(key%10)/1）
• 將桶中數字依次遍歷讀取到目標數列中當成新的數量，
• 高位依次類推，繼續執行第三，第四步驟，直到最高位，得到有序數列。

圖片演示

代碼實現

public static int[] getArrayData(int size) {int[] arrayData = new int[size];Random random = new Random();for (int i = 0; i < size; i++) {int temp = random.nextInt(100);if (temp > 0) {arrayData[i] = temp;} else {int value = temp - 2 * temp;arrayData[i] = value;}}return arrayData;}/** * 時間復雜度 O(N*k) 空間復雜度O(N+k)* @author: liaojiamin* @description: 從小到大基數排序*/public static int[] radixSort(int[] arrayData) {if (null == arrayData || arrayData.length <= 1) {return arrayData;}int max = arrayData[0];for (int i = 0; i < arrayData.length; i++) {if (arrayData[i] > max) {max = arrayData[i];}}int temp = max;int maxDigit = 0;int i = 10;while (temp > 0) {temp /= i;i *= 10;maxDigit++;}int mod = 10;int dev = 1;for (int j = 0; j < maxDigit; j++, dev *= 10, mod *= 10) {//這個地方可以優化，先獲取最大桶的大小，就可以不用每個桶都arrayData.lengthint[][] tempArray = new int[10][arrayData.length];int[] tempIndex = new int[10];for (int k = 0; k < arrayData.length; k++) {int bucket = (arrayData[k]%mod)/dev;if(arrayData[k] > 0){tempArray[bucket][tempIndex[bucket]++] = arrayData[k];}else {tempArray[bucket][tempIndex[bucket]++] = -1;}}int index = 0;for (int s = 0; s < tempIndex.length; s++) {if (tempIndex[s] <= 0){continue;}for (int i1 = 0; i1 < tempIndex[s]; i1++) {if( tempArray[s][i1] > 0){arrayData[index] = tempArray[s][i1];}else {arrayData[index] = 0;}index++;}}}return arrayData;}public static void main(String[] args) {int[] beginArrayData = getArrayData(20);int[] arrayData = radixSort(beginArrayData);for (int i = 0; i < arrayData.length; i++) {System.out.println(arrayData[i]);}}

算法分析

• 基數排序基于對各數據的每一位分別排序，分別收集，所以是穩定的。當基數排序的性能比桶排序略差，每次關鍵字的桶都需要O(n)的時間復雜度，而且分配之后得到新的關鍵字序列又要O(n)時間復雜度，所以時間復雜度取決于最大數據 是 k位，數據總量N因此得出時間復雜度O(2NK)。假如待排序數據可以分為d個關鍵字（最大d位），則基數排序的時間復雜度將是O(d2n)，當然d要遠遠小于n，因此基本上還是線性級別
• 基數排序的空間復雜度O(n+k)，其中k為桶的個數，一般n >> k，因此額外空間需要大概N個左右

上一篇：數據結構與算法–字符串：字符串替換
下一篇：數據結構與算法–簡單棧實現及其應用

總結

以上是生活随笔為你收集整理的数据结构与算法--经典10大排序算法（动图演示）【建议收藏】的全部內容，希望文章能夠幫你解決所遇到的問題。

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