今天對java語言排序演算法進行了深入學習：

Java的幾種常見排序演算法

　　一、所謂排序，就是使一串記錄，按照其中的某個或某些關鍵字的大小，遞增或遞減的排列起來的操作。排序演算法，就是如何使得記錄按照要求排列的方法。排序演算法在很多領域得到相當地重視，尤其是在大量資料的處理方面。一個優秀的演算法可以節省大量的資源。在各個領域中考慮到資料的各種限制和規範，要得到一個符合實際的優秀演算法，得經過大量的推理和分析。

　　二、排序演算法可以分為內部排序和外部排序。

　　　　內部排序是資料記錄在記憶體中進行排序。

　　　　外部排序是因排序的資料很大，一次不能容納全部的排序記錄，在排序過程中需要訪問外存。

　　　　常見的內部排序演算法有：氣泡排序、選擇排序、插入排序、希爾排序、快速排序、歸併排序等。

三、這裡主要介紹常見的幾種排序演算法
　　1）氣泡排序
　　a、氣泡排序，是通過每一次遍歷獲取最大/最小值
　　b、將最大值/最小值放在尾部/頭部
　　c、然後除開最大值/最小值，剩下的資料在進行遍歷獲取最大/最小值
　　d、程式碼實現
publicstaticvoidmain(String[]args){
intarr[]={8,5,3,2,4};
//冒泡
for(inti=0;i<arr.length;i++){
//外層迴圈，遍歷次數
for(intj=0;j<arr.length-i-1;j++){
//內層迴圈，升序（如果前一個值比後一個值大，則交換）
//內層迴圈一次，獲取一個最大值
if(arr[j]>arr[j+1]){
inttemp=arr[j+1];
arr[j+1]=arr[j];
arr[j]=temp;
}
}
}
}
　　2）選擇排序
　　a、將第一個值看成最小值
　　b、然後和後續的比較找出最小值和下標
　　c、交換本次遍歷的起始值和最小值
　　d、說明：每次遍歷的時候，將前面找出的最小值，看成一個有序的列表，後面的看成無序的列表，然後每次遍歷無序列表找出最小值。
　　e、程式碼實現
publicstaticvoidmain(String[]args){
intarr[]={6,5,3,2,4};
//選擇
for(inti=0;i<arr.length;i++){
//預設第一個是最小的。
intmin=arr[i];
//記錄最小的下標
intindex=i;
//通過與後面的資料進行比較得出，最小值和下標
for(intj=i+1;j<arr.length;j++){
if(min>arr[j]){
min=arr[j];
index=j;
}
}
//然後將最小值與本次迴圈的，開始值交換
inttemp=arr[i];
arr[i]=min;
arr[index]=temp;
//說明：將i前面的資料看成一個排好的佇列，i後面的看成一個無序佇列。每次只需要找無需的最小值，做替換
}
}
　　3）插入排序
　　a、預設從第二個資料開始比較。
　　b、如果第二個資料比第一個小，則交換。然後在用第三個資料比較，如果比前面小，則插入（狡猾）。否則，退出迴圈
　　c、說明：預設將第一資料看成有序列表，後面無序的列表迴圈每一個數據，如果比前面的資料小則插入（交換）。否則退出。
　　d、程式碼實現
publicstaticvoidmain(String[]args){
intarr[]={7,5,3,2,4};
//插入排序
for(inti=1;i<arr.length;i++){
//外層迴圈，從第二個開始比較
for(intj=i;j>0;j--){
//記憶體迴圈，與前面排好序的資料比較，如果後面的資料小於前面的則交換
if(arr[j]<arr[j-1]){
inttemp=arr[j-1];
arr[j-1]=arr[j];
arr[j]=temp;
}else{
//如果不小於，說明插入完畢，退出內層迴圈
break;
}
}
}
}
　　4）希爾排序（插入排序變種版）
　　a、基本上和插入排序一樣的道理
　　b、不一樣的地方在於，每次迴圈的步長，通過減半的方式來實現
　　c、說明：基本原理和插入排序類似，不一樣的地方在於。通過間隔多個數據來進行插入排序。
　　d、程式碼實現
publicstaticvoidmain(String[]args){
intarr[]={7,5,3,2,4};
//希爾排序（插入排序變種版）
for(inti=arr.length/2;i>0;i/=2){
//i層迴圈控制步長
for(intj=i;j<arr.length;j++){
//j控制無序端的起始位置
for(intk=j;k>0&&k-i>=0;k-=i){
if(arr[k]<arr[k-i]){
inttemp=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、程式碼實現

複製程式碼
publicstaticvoidmain(String[]args){

intarr[]={7,5,3,2,4,1,8,9,6};

//快速排序
intlow=0;
inthigh=arr.length-1;
quickSort(arr,low,high);
}

publicstaticvoidquickSort(int[]arr,intlow,inthigh){
//如果指標在同一位置(只有一個數據時)，退出
if(high-low<1){
return;
}
//標記，從高指標開始，還是低指標（預設高指標）
booleanflag=true;
//記錄指標的其實位置
intstart=low;
intend=high;
//預設中間值為低指標的第一個值
intmidValue=arr[low];
while(true){
//高指標移動
if(flag){
//如果列表右方的資料大於中間值，則向左移動
if(arr[high]>midValue){
high--;
}elseif(arr[high]<midValue){
//如果小於，則覆蓋最開始的低指標值，並且移動低指標，標誌位改成從低指標開始移動
arr[low]=arr[high];
low++;
flag=false;
}
}else{
//如果低指標資料小於中間值，則低指標向右移動
if(arr[low]<midValue){
low++;
}elseif(arr[low]>midValue){
//如果低指標的值大於中間值，則覆蓋高指標停留時的資料，並向左移動高指標。切換為高指標移動
arr[high]=arr[low];
high--;
flag=true;
}
}
//當兩個指標的位置相同時，則找到了中間值的位置，並退出迴圈
if(low==high){
arr[low]=midValue;
break;
}
}
//然後出現有，中間值左邊的小於中間值。右邊的大於中間值。
//然後在對左右兩邊的列表在進行快速排序
quickSort(arr,start,low-1);
quickSort(arr,low+1,end);
}
複製程式碼
　　h、排序過程(青色：中間值，藍色：確認位置的資料，紅色：移動的資料)

複製程式碼
6,5,3,2,4,1,7,9,8
1,5,3,2,4,6,7,9,8
1,5,3,2,4,6,7,9,8
1,4,3,2,5,6,7,9,8
1,2,3,4,5,6,7,9,8
1,2,3,4,5,6,7,9,8
1,2,3,4,5,6,7,8,9
複製程式碼
　　6）歸併排序
　　a、將列表按照對等的方式進行拆分
　　b、拆分小最小快的時候，在將最小塊按照原來的拆分，進行合併
　　c、合併的時候，通過左右兩塊的左邊開始比較大小。小的資料放入新的塊中
　　d、說明：簡單一點就是先對半拆成最小單位，然後將兩半資料合併成一個有序的列表。
　　e、程式碼實現
publicstaticvoidmain(String[]args){
intarr[]={7,5,3,2,4,1，6};
//歸併排序
intstart=0;
intend=arr.length-1;
mergeSort(arr,start,end);
}
publicstaticvoidmergeSort(int[]arr,intstart,intend){
//判斷拆分的不為最小單位
if(end-start>0){
//再一次拆分，知道拆成一個一個的資料
mergeSort(arr,start,(start+end)/2);
mergeSort(arr,(start+end)/2+1,end);
//記錄開始/結束位置
intleft=start;
intright=(start+end)/2+1;
//記錄每個小單位的排序結果
intindex=0;
int[]result=newint[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(inti=start;i<=end;i++){
arr[i]=result[i-start];
}
}
}