一、所謂排序，就是使一串記錄，按照其中的某個或某些關鍵字的大小，遞增或遞減的排列起來的操作。排序算法，就是如何使得記錄按照要求排列的方法。排序算法在很多領域得到相當地重視，尤其是在大量數據的處理方面。一個優秀的算法可以節省大量的資源。在各個領域中考慮到數據的各種限制和規範，要得到一個符合實際的優秀算法，得經過大量的推理和分析。
二、排序算法可以分爲內部排序和外部排序。
內部排序是數據記錄在內存中進行排序。
外部排序是因排序的數據很大，一次不能容納全部的排序記錄，在排序過程中需要訪問外存。
常見的內部排序算法有:冒泡排序, 選擇排序,插入排序,希爾排序,快速排序,歸併排序等.
當然：實際的排序算法可不止這麼一點，如果像瞭解其他算法可以參考：https://baike.baidu.com/item/%E6%8E%92%E5%BA%8F%E7%AE%97%E6%B3%95/5399605?fr=aladdin#3
三、這裏主要介紹常見的幾種排序算法
1) 冒泡排序low版本
a、冒泡排序，是通過每一次遍歷獲取最大/最小值
b、將最大值/最小值放在尾部/頭部
c、然後除開最大值/最小值，剩下的數據在進行遍歷獲取最大/最小值
d、代碼實現
public class MaoPao { public static void sort(int[] arr){ for (int i = 1; i < arr.length; i++) { //第一層for循環,用來控制冒泡的次數 for (int j = 0; j < arr.length-1; j++) { //第二層for循環,用來控制冒泡一層層到最後 //如果前一個數比後一個數大,兩者調換 ,意味着泡泡向上走了一層 if (arr[j] > arr[j+1] ){ int temp = arr[j]; arr[j] = arr[j+1]; arr[j+1] = temp; } } } } }
冒泡的bigger版本
在這個版本中,改動了兩點
第一點是加入了一個布爾值,判斷第二層循環中的調換有沒有執行,如果沒有進行兩兩調換,說明後面都已經排好序了,已經不需要再循環了,直接跳出循環,排序結束.
第二點是第二層循環不再循環到arr.length - 1,因爲外面的i循環遞增一次,說明數組最後就多了一個排好序的大泡泡.第二層循環也就不需要到最末尾一位了,可以提前結束循環
/** * 終極版冒泡排序 * 加入一個布爾變量,如果內循環沒有交換值,說明已經排序完成,提前終止 * @param arr */ public static void sortPlus(int[] arr){ if(arr != null && arr.length > 1){ for(int i = 0; i < arr.length - 1; i++){ // 初始化一個布爾值 boolean flag = true; for(int j = 0; j < arr.length - i - 1 ; j++){ if(arr[j] > arr[j+1]){ // 調換 int temp; temp = arr[j]; arr[j] = arr[j+1]; arr[j+1] = temp; // 改變flag flag = false; } } if(flag){ break; } } } }
2）選擇排序
a、將第一個值看成最小值
b、然後和後續的比較找出最小值和下標
c、交換本次遍歷的起始值和最小值
d、說明：每次遍歷的時候，將前面找出的最小值，看成一個有序的列表，後面的看成無序的列表，然後每次遍歷無序列表找出最小值。
e、代碼實現
public static void main(String[] args) { int arr[] = {6, 5, 3, 2, 4}; //選擇 for (int i = 0; i < arr.length; i++) { //默認第一個是最小的。 int min = arr[i]; //記錄最小的下標 int index = i; //通過與後面的數據進行比較得出，最小值和下標 for (int j = i + 1; j < arr.length; j++) { if (min > arr[j]) { min = arr[j]; index = j; } } //然後將最小值與本次循環的，開始值交換 int temp = arr[i]; arr[i] = min; arr[index] = temp; //說明：將i前面的數據看成一個排好的隊列，i後面的看成一個無序隊列。每次只需要找無需的最小值，做替換 } }
3）插入排序
a、默認從第二個數據開始比較。
b、如果第二個數據比第一個小，則交換。然後在用第三個數據比較，如果比前面小，則插入（狡猾）。否則，退出循環
c、說明：默認將第一數據看成有序列表，後面無序的列表循環每一個數據，如果比前面的數據小則插入（交換）。否則退出。
d、代碼實現
public static void main(String[] args) { int arr[] = {7, 5, 3, 2, 4}; //插入排序 for (int i = 1; i < arr.length; i++) { //外層循環，從第二個開始比較 for (int j = i; j > 0; j--) { //內存循環，與前面排好序的數據比較，如果後面的數據小於前面的則交換 if (arr[j] < arr[j - 1]) { int temp = arr[j - 1]; arr[j - 1] = arr[j]; arr[j] = temp; } else { //如果不小於，說明插入完畢，退出內層循環 break; } } } }
4）希爾排序（插入排序變種版）
a、基本上和插入排序一樣的道理
b、不一樣的地方在於，每次循環的步長，通過減半的方式來實現
c、說明：基本原理和插入排序類似，不一樣的地方在於。通過間隔多個數據來進行插入排序。
d、代碼實現
public static void main(String[] args) { int arr[] = {7, 5, 3, 2, 4}; //希爾排序（插入排序變種版） for (int i = arr.length / 2; i > 0; i /= 2) { //i層循環控制步長 for (int j = i; j < arr.length; j++) { //j控制無序端的起始位置 for (int k = j; k > 0 && k - i >= 0; k -= i) { if (arr[k] < arr[k - i]) { int temp = arr[k - i]; arr[k - i] = arr[k]; arr[k] = temp; } else { break; } } } //j,k爲插入排序，不過步長爲i } }
5）快速排序
a、確認列表第一個數據爲中間值，第一個值看成空缺（低指針空缺）。
b、然後在剩下的隊列中，看成有左右兩個指針（高低）。
c、開始高指針向左移動，如果遇到小於中間值的數據，則將這個數據賦值到低指針空缺，並且將高指針的數據看成空缺值（高指針空缺）。然後先向右移動一下低指針，並且切換低指針移動。
d、當低指針移動到大於中間值的時候，賦值到高指針空缺的地方。然後先高指針向左移動，並且切換高指針移動。重複c、d操作。
e、直到高指針和低指針相等時退出，並且將中間值賦值給對應指針位置。
f、然後將中間值的左右兩邊看成行的列表，進行快速排序操作。
g、代碼實現
public class Sort { public static void main(String[] args) { int arr[] = {7, 5, 3, 2, 4, 1, 8, 9, 6}; //快速排序 int low = 0; int high = arr.length - 1; quickSort(arr, low, high); } public static void quickSort(int[] arr,int begin,int end) { //先定義兩個參數接收排序起始值和結束值 int a = begin; int b = end; //先判斷a是否大於b if (a >= b) { //沒必要排序 return; } //基準數,默認設置爲第一個值 int x = arr[a]; //循環 while (a < b) { //從後往前找,找到一個比基準數x小的值,賦給arr[a] //如果a和b的邏輯正確--a<b ,並且最後一個值arr[b]>x,就一直往下找,直到找到後面的值大於x while (a < b && arr[b] >= x) { b--; } //跳出循環,兩種情況,一是a和b的邏輯不對了,a>=b,這時候排序結束.二是在後面找到了比x小的值 if (a < b) { //將這時候找到的arr[b]放到最前面arr[a] arr[a] = arr[b]; //排序的起始位置後移一位 a++; } //從前往後找,找到一個比基準數x大的值,放在最後面arr[b] while (a < b && arr[a] <= x) { a++; } if (a < b) { arr[b] = arr[a]; //排序的終止位置前移一位 b--; } } //跳出循環 a < b的邏輯不成立了,a==b重合了,此時將x賦值回去arr[a] arr[a] = x; //調用遞歸函數,再細分再排序 quickSort(arr,begin,a-1); quickSort(arr,a+1,end); } }
6）歸併排序
a、將列表按照對等的方式進行拆分
b、拆分小最小快的時候，在將最小塊按照原來的拆分，進行合併
c、合併的時候，通過左右兩塊的左邊開始比較大小。小的數據放入新的塊中
d、說明：簡單一點就是先對半拆成最小單位，然後將兩半數據合併成一個有序的列表。
e、代碼實現
public static void main(String[] args) { int arr[] = {7, 5, 3, 2, 4, 1，6}; //歸併排序 int start = 0; int end = arr.length - 1; mergeSort(arr, start, end); } public static void mergeSort(int[] arr, int start, int end) { //判斷拆分的不爲最小單位 if (end - start > 0) { //再一次拆分，知道拆成一個一個的數據 mergeSort(arr, start, (start + end) / 2); mergeSort(arr, (start + end) / 2 + 1, end); //記錄開始/結束位置 int left = start; int right = (start + end) / 2 + 1; //記錄每個小單位的排序結果 int index = 0; int[] result = new int[end - start + 1]; //如果查分後的兩塊數據，都還存在 while (left <= (start + end) / 2 && right <= end) { //比較兩塊數據的大小，然後賦值，並且移動下標 if (arr[left] <= arr[right]) { result[index] = arr[left]; left++; } else { result[index] = arr[right]; right++; } //移動單位記錄的下標 index++; } //當某一塊數據不存在了時 while (left <= (start + end) / 2 || right <= end) { //直接賦值到記錄下標 if (left <= (start + end) / 2) { result[index] = arr[left]; left++; } else { result[index] = arr[right]; right++; } index++; } //最後將新的數據賦值給原來的列表，並且是對應分塊後的下標。 for (int i = start; i <= end; i++) { arr[i] = result[i - start]; } } }
7)其他排序
比如Arrays工具類提供的排序方法。它內部實現也是快速排序
private static void arraysSort(int[] a){ Arrays.sort(a); }
還有就是將數組轉爲list,使用集合的排序方法,但是這無異於兜圈子,因爲集合底層也是數組
private static void listSort(int[] a){ List<Integer> integers = Ints.asList(a); Collections.sort(integers); integers.toArray(new Integer[a.length]); }
參考博客:https://www.cnblogs.com/ll409546297/p/10956960.html