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。
代碼如下：
public void insertSort(int [] a){ int len=a.length;//單獨把數組長度拿出來，提高效率 int insertNum;//要插入的數 for(int i=1;i<len;i++){//因為第一次不用，所以從1開始 insertNum=a[i]; intj=i-1;//序列元素個數 while(j>=0&&a[j]>insertNum){//從後往前循環，將大於insertNum的數向後移動 a[j+1]=a[j];//元素向後移動 j--; } a[j+1]=insertNum;//找到位置，插入當前元素 } }
2.希爾排序
針對直接插入排序的下效率問題，有人對次進行了改進與升級，這就是現在的希爾排序。希爾排序，也稱遞減增量排序算法，是插入排序的一種更高效的改進版本。希爾排序是非穩定排序算法。
希爾排序是基於插入排序的以下兩點性質而提出改進方法的：
- 插入排序在對幾乎已經排好序的數據操作時， 效率高， 即可以達到線性排序的效率
- 但插入排序一般來說是低效的， 因為插入排序每次只能將數據移動一位
如圖所示：
對於直接插入排序問題，數據量巨大時。
將數的個數設為n，取奇數k=n/2，將下標差值為k的數分為一組，構成有序序列。
再取k=k/2 ，將下標差值為k的書分為一組，構成有序序列。
重復第二步，直到k=1執行簡單插入排序。
代碼實現：
首先確定分的組數。
然後對組中元素進行插入排序。
然後將length/2，重復1,2步，直到length=0為止。
public void sheelSort(int [] a){ int len=a.length;//單獨把數組長度拿出來，提高效率 while(len!=0){ len=len/2; for(int i=0;i<len;i++){//分組 for(int j=i+len;j<a.length;j+=len){//元素從第二個開始 int k=j-len;//k為有序序列最後一位的位數 int temp=a[j];//要插入的元素 /*for(;k>=0&&temp<a[k];k-=len){ a[k+len]=a[k]; }*/ while(k>=0&&temp<a[k]){//從後往前遍歷 a[k+len]=a[k]; k-=len;//向後移動len位 } a[k+len]=temp; } } } }
3.簡單選擇排序
常用於取序列中最大最小的幾個數時。
(如果每次比較都交換，那麽就是交換排序；如果每次比較完一個循環再交換，就是簡單選擇排序。)
遍歷整個序列，將最小的數放在最前面。
遍歷剩下的序列，將最小的數放在最前面。
重復第二步，直到只剩下一個數。
代碼實現：
首先確定循環次數，並且記住當前數字和當前位置。
將當前位置後面所有的數與當前數字進行對比，小數賦值給key，並記住小數的位置。
比對完成後，將最小的值與第一個數的值交換。
重復2、3步。
public void selectSort(int[]a){ int len=a.length; for(int i=0;i<len;i++){//循環次數 int value=a[i]; int position=i; for(int j=i+1;j<len;j++){//找到最小的值和位置 if(a[j]<value){ value=a[j]; position=j; } } a[position]=a[i];//進行交換 a[i]=value; } }
4.堆排序
對簡單選擇排序的優化。
將序列構建成大頂堆。
將根節點與最後一個節點交換，然後斷開最後一個節點。
重復第一、二步，直到所有節點斷開。
代碼如下：
public void heapSort(int[] a){ int len=a.length; //循環建堆 for(int i=0;i<len-1;i++){ //建堆 buildMaxHeap(a,len-1-i); //交換堆頂和最後一個元素 swap(a,0,len-1-i); } } //交換方法 private void swap(int[] data, int i, int j) { int tmp=data[i]; data[i]=data[j]; data[j]=tmp; } //對data數組從0到lastIndex建大頂堆 private void buildMaxHeap(int[] data, int lastIndex) { //從lastIndex處節點（最後一個節點）的父節點開始 for(int i=(lastIndex-1)/2;i>=0;i--){ //k保存正在判斷的節點 int k=i; //如果當前k節點的子節點存在 while(k*2+1<=lastIndex){ //k節點的左子節點的索引 int biggerIndex=2*k+1; //如果biggerIndex小於lastIndex，即biggerIndex+1代表的k節點的右子節點存在 if(biggerIndex<lastIndex){ //若果右子節點的值較大 if(data[biggerIndex]<data[biggerIndex+1]){ //biggerIndex總是記錄較大子節點的索引 biggerIndex++; } } //如果k節點的值小於其較大的子節點的值 if(data[k]<data[biggerIndex]){ //交換他們 swap(data,k,biggerIndex); //將biggerIndex賦予k，開始while循環的下一次循環，重新保證k節點的值大於其左右子節點的值 k=biggerIndex; }else{ break; } } } }
5.冒泡排序
很簡單，用到的很少，據了解，面試的時候問的比較多！
將序列中所有元素兩兩比較，將最大的放在最後面。
將剩余序列中所有元素兩兩比較，將最大的放在最後面。
重復第二步，直到只剩下一個數。
代碼實現：
設置循環次數。
設置開始比較的位數，和結束的位數。
兩兩比較，將最小的放到前面去。
重復2、3步，直到循環次數完畢。
public void bubbleSort(int []a){ int len=a.length; for(int i=0;i<len;i++){ for(int j=0;j<len-i-1;j++){//註意第二重循環的條件 if(a[j]>a[j+1]){ int temp=a[j]; a[j]=a[j+1]; a[j+1]=temp; } } } }
6.快速排序
要求時間最快時。
選擇第一個數為p，小於p的數放在左邊，大於p的數放在右邊。
遞歸的將p左邊和右邊的數都按照第一步進行，直到不能遞歸。
public void quickSort(int[]a,int start,int end){ if(start<end){ int baseNum=a[start];//選基準值 int midNum;//記錄中間值 int i=start; int j=end; do{ while((a[i]<baseNum)&&i<end){ i++; } while((a[j]>baseNum)&&j>start){ j--; } if(i<=j){ midNum=a[i]; a[i]=a[j]; a[j]=midNum; i++; j--; } }while(i<=j); if(start<j){ quickSort(a,start,j); } if(end>i){ quickSort(a,i,end); } } }
7.歸並排序
速度僅次於快速排序，內存少的時候使用，可以進行並行計算的時候使用。
選擇相鄰兩個數組成一個有序序列。
選擇相鄰的兩個有序序列組成一個有序序列。
重復第二步，直到全部組成一個有序序列。
public void mergeSort(int[] a, int left, int right) { int t = 1;// 每組元素個數 int size = right - left + 1; while (t < size) { int s = t;// 本次循環每組元素個數 t = 2 * s; int i = left; while (i + (t - 1) < size) { merge(a, i, i + (s - 1), i + (t - 1)); i += t; } if (i + (s - 1) < right) merge(a, i, i + (s - 1), right); } } private static void merge(int[] data, int p, int q, int r) { int[] B = new int[data.length]; int s = p; int t = q + 1; int k = p; while (s <= q && t <= r) { if (data[s] <= data[t]) { B[k] = data[s]; s++; } else { B[k] = data[t]; t++; } k++; } if (s == q + 1) B[k++] = data[t++]; else B[k++] = data[s++]; for (int i = p; i <= r; i++) data[i] = B[i]; }
8.基數排序
用於大量數，很長的數進行排序時。
將所有的數的個位數取出，按照個位數進行排序，構成一個序列。
將新構成的所有的數的十位數取出，按照十位數進行排序，構成一個序列。
代碼實現：
public void baseSort(int[] a) { //首先確定排序的趟數; int max = a[0]; for (int i = 1; i < a.length; i++) { if (a[i] > max) { max = a[i]; } } int time = 0; //判斷位數; while (max > 0) { max /= 10; time++; } //建立10個隊列; List<ArrayList<Integer>> queue = new ArrayList<ArrayList<Integer>>(); for (int i = 0; i < 10; i++) { ArrayList<Integer> queue1 = new ArrayList<Integer>(); queue.add(queue1); } //進行time次分配和收集; for (int i = 0; i < time; i++) { //分配數組元素; for (int j = 0; j < a.length; j++) { //得到數字的第time+1位數; int x = a[j] % (int) Math.pow(10, i + 1) / (int) Math.pow(10, i); ArrayList<Integer> queue2 = queue.get(x); queue2.add(a[j]); queue.set(x, queue2); } int count = 0;//元素計數器; //收集隊列元素; for (int k = 0; k < 10; k++) { while (queue.get(k).size() > 0) { ArrayList<Integer> queue3 = queue.get(k); a[count] = queue3.get(0); queue3.remove(0); count++; } } } }
新建測試類進行測試
public class TestSort { public static void main(String[] args) { int []a=new int[10]; for(int i=1;i<a.length;i++){ //a[i]=(int)(new Random().nextInt(100)); a[i]=(int)(Math.random()*100); } System.out.println("排序前的數組為："+Arrays.toString(a)); Sort s=new Sort(); //排序方法測試 //s.insertSort(a); //s.sheelSort(a); //s.selectSort(a); //s.heapSort(a); //s.bubbleSort(a); //s.quickSort(a, 1, 9); //s.mergeSort(a, 3, 7); s.baseSort(a); System.out.println("排序後的數組為："+Arrays.toString(a)); } }
部分結果如下:
如果要進行比較可已加入時間，輸出排序時間，從而比較各個排序算法的優缺點，這裏不再做介紹。
總結：
一、穩定性:
穩定：冒泡排序、插入排序、歸並排序和基數排序
不穩定：選擇排序、快速排序、希爾排序、堆排序
二、平均時間復雜度
O(n^2):直接插入排序，簡單選擇排序，冒泡排序。
在數據規模較小時（9W內），直接插入排序，簡單選擇排序差不多。當數據較大時，冒泡排序算法的時間代價最高。性能為O(n^2)的算法基本上是相鄰元素進行比較，基本上都是穩定的。
O(nlogn):快速排序，歸並排序，希爾排序，堆排序。
其中，快排是最好的， 其次是歸並和希爾，堆排序在數據量很大時效果明顯。
三、排序算法的選擇
1.數據規模較小
（1）待排序列基本序的情況下，可以選擇直接插入排序；
（2）對穩定性不作要求宜用簡單選擇排序，對穩定性有要求宜用插入或冒泡
2.數據規模不是很大
（1）完全可以用內存空間，序列雜亂無序，對穩定性沒有要求，快速排序，此時要付出log（N）的額外空間。
（2）序列本身可能有序，對穩定性有要求，空間允許下，宜用歸並排序
3.數據規模很大
（1）對穩定性有求，則可考慮歸並排序。
（2）對穩定性沒要求，宜用堆排序
4.序列初始基本有序（正序），宜用直接插入，冒泡
各算法復雜度如下：
排序算法經典題
三色排序
問題描述
輸入一個整型數組，每個元素在0~2之間，其中0，1，2分別代表紅、白、藍。現要求對數組進行排序，相同顏色的在一起，而且按紅白藍順序先後排列。要求時間復雜度為O(n)。
問題分析
最容易想到的是排序，比如快排，歸並，堆排等，但它們的時間復雜度為O(nlogn)，與題意不符。
第二種想到的是計數排序，掃描一遍過去，分別記錄0，1，2的個數，然後再對數組進行賦值。時間復雜度為O(2n)，即O(n)，滿足條件。
還有一種方法，只需掃描一遍數組即可，其充分利用了元素只有3種的特性：在掃描數組的時候，使用首尾倆個指針，分別指示0、1與1、2邊界。比如源數組為{2， 2， 0， 0， 1， 1 }。
第一步：首指針p0，尾指針p1，i標識當前掃描位置，當前位置值為2，需要將其交換至尾指針p1位置，p1要向前移動一位，p0、i位置不變。
第二步：i位置值不為0、2，i要向後移動一位，p0、p1位置不變。
第三步：i位置值為2，需要將其交換至尾指針p1位置，並且p1往前移動一位，i與p0位置不變。
第四步：i位置不為0、2，i要向後移動一位，p0、p1位置不變。
第五步：i位置值為0，需要將其交換至首指針p0位置，並且p0往後移動一位，i與p1位置不變。
第六步：i位置不為0、2，i要向後移動一位，p0、p1位置不變。
第七步：i位置值為0，需要將其交換至首指針p0位置，並且p0往後移動一位，i與p1位置不變。
第八步：i位置不為0、2，i要向後移動一位，p0、p1位置不變。
第九步：i位置超過p1位置了，結束。
實現代碼
#include <iostream> using namespace std; void ThreeColorSort( int nArray[], int nCount ) { int p0 = 0; //首指針 int p1 = nCount-1; //尾指針 int i = 1; while( i <= p1 ) { //當前值為2，與尾指針p1指向的值相互交換，p1向前移動一位 //i、p0位置不變 if ( nArray[i] == 2 ) { int nTemp = nArray[i]; nArray[i] = nArray[p1]; nArray[p1--] = nTemp; } //當前值為0，與首指針p0指向的值相互交換，p0向後移動一位 //i、p0位置不變 else if ( nArray[i] == 0 && i > p0 ) { int nTemp = nArray[i]; nArray[i] = nArray[p0]; nArray[p0++] = nTemp; } //i位置不為0、2，i要向後移動一位，p0、p1位置不變。 else { ++i; } } } //書上的例子代碼 void SortColors( int nArray[], int nCount ) { int p0 = 0; int p2 = nCount; for( int i = 0; i < p2; ++i ) { if ( nArray[i] == 0 ) { int tmp = nArray[p0]; nArray[p0] = nArray[i]; nArray[i] = tmp; ++p0; } else if ( nArray[i] == 2 ) { --p2; int tmp = nArray[p2]; nArray[p2] = nArray[i]; nArray[i] = tmp; --i; } } } int main() { //int nArray[] = { 2, 1, 0, 2, 0 }; //int nArray[] = { 0, 0, 1, 1, 2, 2 }; //int nArray[] = { 0 }; //int nArray[] = { 2, 0, 1 }; int nArray[] = { 2, 2, 0, 0, 1, 1 }; ThreeColorSort( nArray, _countof(nArray) ); //SortColors( nArray, _countof(nArray) ); for( int i = 0; i < _countof(nArray); ++i ) { cout << nArray[i] << " "; } cout << endl; return 0; }
Java數據結構和算法（三）：常用排序算法與經典題型