Java常用的八種排序演算法與程式碼實現--轉載
1.直接插入排序
我們經常會到這樣一類排序問題：把新的資料插入到已經排好的資料列中。將第一個數和第二個數排序，然後構成一個有序序列將第三個數插入進去，構成一個新的有序序列。對第四個數、第五個數……直到最後一個數，重複第二步。如題所示：
直接插入排序（Straight Insertion Sorting）的基本思想：在要排序的一組數中，假設前面(n-1) [n>=2] 個數已經是排好順序的，現在要把第n個數插到前面的有序數中，使得這n個數也是排好順序的。如此反覆迴圈，直到全部排好順序。
程式碼實現：
首先設定插入次數，即迴圈次數，for(int i=1;i<length;i++)，1個數的那次不用插入。
設定插入數和得到已經排好序列的最後一個數的位數。insertNum和j=i-1。
從最後一個數開始向前迴圈，如果插入數小於當前數，就將當前數向後移動一位。
將當前數放置到空著的位置，即j+1。
程式碼如下：
1 public void insertSort(int [] a){ 2 int len=a.length;//單獨把陣列長度拿出來，提高效率 3 int insertNum;//要插入的數 4 for(int i=1;i<len;i++){//因為第一次不用，所以從1開始 5 insertNum=a[i]; 6 intj=i-1;//序列元素個數 7 while(j>0&&a[j]>insertNum){//從後往前迴圈，將大於insertNum的數向後移動 8 a[j+1]=a[j];//元素向後移動 9 j--; 10 } 11 a[j+1]=insertNum;//找到位置，插入當前元素 12 } 13 }
2.希爾排序
針對直接插入排序的下效率問題，有人對次進行了改進與升級，這就是現在的希爾排序。希爾排序，也稱遞減增量排序演算法
希爾排序是基於插入排序的以下兩點性質而提出改進方法的：
- 插入排序在對幾乎已經排好序的資料操作時， 效率高， 即可以達到線性排序的效率
- 但插入排序一般來說是低效的， 因為插入排序每次只能將資料移動一位
如圖所示：
對於直接插入排序問題，資料量巨大時。
將數的個數設為n，取奇數k=n/2，將下標差值為k的數分為一組，構成有序序列。
再取k=k/2 ，將下標差值為k的書分為一組，構成有序序列。
重複第二步，直到k=1執行簡單插入排序。
程式碼實現：
首先確定分的組數。
然後對組中元素進行插入排序。
然後將length/2，重複1,2步，直到length=0為止。
1 public void sheelSort(int [] a){ 2 int len=a.length;//單獨把陣列長度拿出來，提高效率 3 while(len!=0){ 4 len=len/2; 5 for(int i=0;i<len;i++){//分組 6 for(int j=i+len;j<a.length;j+=len){//元素從第二個開始 7 int k=j-len;//k為有序序列最後一位的位數 8 int temp=a[j];//要插入的元素 9 /*for(;k>=0&&temp<a[k];k-=len){ 10 a[k+len]=a[k]; 11 }*/ 12 while(k>=0&&temp<a[k]){//從後往前遍歷 13 a[k+len]=a[k]; 14 k-=len;//向後移動len位 15 } 16 a[k+len]=temp; 17 } 18 } 19 } 20 }
3.簡單選擇排序
常用於取序列中最大最小的幾個數時。
(如果每次比較都交換，那麼就是交換排序；如果每次比較完一個迴圈再交換，就是簡單選擇排序。)
遍歷整個序列，將最小的數放在最前面。
遍歷剩下的序列，將最小的數放在最前面。
重複第二步，直到只剩下一個數。
程式碼實現：
首先確定迴圈次數，並且記住當前數字和當前位置。
將當前位置後面所有的數與當前數字進行對比，小數賦值給key，並記住小數的位置。
比對完成後，將最小的值與第一個數的值交換。
重複2、3步。
1 public void selectSort(int[]a){ 2 int len=a.length; 3 for(int i=0;i<len;i++){//迴圈次數 4 int value=a[i]; 5 int position=i; 6 for(int j=i+1;j<len;j++){//找到最小的值和位置 7 if(a[j]<value){ 8 value=a[j]; 9 position=j; 10 } 11 } 12 a[position]=a[i];//進行交換 13 a[i]=value; 14 } 15 }
4.堆排序
對簡單選擇排序的優化。
將序列構建成大頂堆。
將根節點與最後一個節點交換，然後斷開最後一個節點。
重複第一、二步，直到所有節點斷開。
程式碼如下：
1 public void heapSort(int[] a){ 2 int len=a.length; 3 //迴圈建堆 4 for(int i=0;i<len-1;i++){ 5 //建堆 6 buildMaxHeap(a,len-1-i); 7 //交換堆頂和最後一個元素 8 swap(a,0,len-1-i); 9 } 10 } 11 //交換方法 12 private void swap(int[] data, int i, int j) { 13 int tmp=data[i]; 14 data[i]=data[j]; 15 data[j]=tmp; 16 } 17 //對data陣列從0到lastIndex建大頂堆 18 private void buildMaxHeap(int[] data, int lastIndex) { 19 //從lastIndex處節點（最後一個節點）的父節點開始 20 for(int i=(lastIndex-1)/2;i>=0;i--){ 21 //k儲存正在判斷的節點 22 int k=i; 23 //如果當前k節點的子節點存在 24 while(k*2+1<=lastIndex){ 25 //k節點的左子節點的索引 26 int biggerIndex=2*k+1; 27 //如果biggerIndex小於lastIndex，即biggerIndex+1代表的k節點的右子節點存在 28 if(biggerIndex<lastIndex){ 29 //若果右子節點的值較大 30 if(data[biggerIndex]<data[biggerIndex+1]){ 31 //biggerIndex總是記錄較大子節點的索引 32 biggerIndex++; 33 } 34 } 35 //如果k節點的值小於其較大的子節點的值 36 if(data[k]<data[biggerIndex]){ 37 //交換他們 38 swap(data,k,biggerIndex); 39 //將biggerIndex賦予k，開始while迴圈的下一次迴圈，重新保證k節點的值大於其左右子節點的值 40 k=biggerIndex; 41 }else{ 42 break; 43 } 44 } 45 } 46 }
5.氣泡排序
很簡單，用到的很少，據瞭解，面試的時候問的比較多！
將序列中所有元素兩兩比較，將最大的放在最後面。
將剩餘序列中所有元素兩兩比較，將最大的放在最後面。
重複第二步，直到只剩下一個數。
程式碼實現：
設定迴圈次數。
設定開始比較的位數，和結束的位數。
兩兩比較，將最小的放到前面去。
重複2、3步，直到迴圈次數完畢。
1 public void bubbleSort(int []a){ 2 int len=a.length; 3 for(int i=0;i<len;i++){ 4 for(int j=0;j<len-i-1;j++){//注意第二重迴圈的條件 5 if(a[j]>a[j+1]){ 6 int temp=a[j]; 7 a[j]=a[j+1]; 8 a[j+1]=temp; 9 } 10 } 11 } 12 }
6.快速排序
要求時間最快時。
選擇第一個數為p，小於p的數放在左邊，大於p的數放在右邊。
遞迴的將p左邊和右邊的數都按照第一步進行，直到不能遞迴。
1 public void quickSort(int[]a,int start,int end){ 2 if(start<end){ 3 int baseNum=a[start];//選基準值 4 int midNum;//記錄中間值 5 int i=start; 6 int j=end; 7 do{ 8 while((a[i]<baseNum)&&i<end){ 9 i++; 10 } 11 while((a[j]>baseNum)&&j>start){ 12 j--; 13 } 14 if(i<=j){ 15 midNum=a[i]; 16 a[i]=a[j]; 17 a[j]=midNum; 18 i++; 19 j--; 20 } 21 }while(i<=j); 22 if(start<j){ 23 quickSort(a,start,j); 24 } 25 if(end>i){ 26 quickSort(a,i,end); 27 } 28 } 29 }
7.歸併排序
速度僅次於快速排序，記憶體少的時候使用，可以進行平行計算的時候使用。
選擇相鄰兩個陣列成一個有序序列。
選擇相鄰的兩個有序序列組成一個有序序列。
重複第二步，直到全部組成一個有序序列。
1 public void mergeSort(int[] a, int left, int right) { 2 int t = 1;// 每組元素個數 3 int size = right - left + 1; 4 while (t < size) { 5 int s = t;// 本次迴圈每組元素個數 6 t = 2 * s; 7 int i = left; 8 while (i + (t - 1) < size) { 9 merge(a, i, i + (s - 1), i + (t - 1)); 10 i += t; 11 } 12 if (i + (s - 1) < right) 13 merge(a, i, i + (s - 1), right); 14 } 15 } 16 17 private static void merge(int[] data, int p, int q, int r) { 18 int[] B = new int[data.length]; 19 int s = p; 20 int t = q + 1; 21 int k = p; 22 while (s <= q && t <= r) { 23 if (data[s] <= data[t]) { 24 B[k] = data[s]; 25 s++; 26 } else { 27 B[k] = data[t]; 28 t++; 29 } 30 k++; 31 } 32 if (s == q + 1) 33 B[k++] = data[t++]; 34 else 35 B[k++] = data[s++]; 36 for (int i = p; i <= r; i++) 37 data[i] = B[i]; 38 }
7.基數排序
用於大量數，很長的數進行排序時。
將所有的數的個位數取出，按照個位數進行排序，構成一個序列。
將新構成的所有的數的十位數取出，按照十位數進行排序，構成一個序列。
程式碼實現：
1 public void baseSort(int[] a) { 2 //首先確定排序的趟數; 3 int max = a[0]; 4 for (int i = 1; i < a.length; i++) { 5 if (a[i] > max) { 6 max = a[i]; 7 } 8 } 9 int time = 0; 10 //判斷位數; 11 while (max > 0) { 12 max /= 10; 13 time++; 14 } 15 //建立10個佇列; 16 List<ArrayList<Integer>> queue = new ArrayList<ArrayList<Integer>>(); 17 for (int i = 0; i < 10; i++) { 18 ArrayList<Integer> queue1 = new ArrayList<Integer>(); 19 queue.add(queue1); 20 } 21 //進行time次分配和收集; 22 for (int i = 0; i < time; i++) { 23 //分配陣列元素; 24 for (int j = 0; j < a.length; j++) { 25 //得到數字的第time+1位數; 26 int x = a[j] % (int) Math.pow(10, i + 1) / (int) Math.pow(10, i); 27 ArrayList<Integer> queue2 = queue.get(x); 28 queue2.add(a[j]); 29 queue.set(x, queue2); 30 } 31 int count = 0;//元素計數器; 32 //收集佇列元素; 33 for (int k = 0; k < 10; k++) { 34 while (queue.get(k).size() > 0) { 35 ArrayList<Integer> queue3 = queue.get(k); 36 a[count] = queue3.get(0); 37 queue3.remove(0); 38 count++; 39 } 40 } 41 } 42 }
新建測試類進行測試
1