1.冒泡排序
? ?(1) 比較領近的兩個數
(2) 如果左邊的比右邊的數字大，則交換位置
(3) 向右移動一位，繼續比較相鄰的兩個數
? 排序示例：
?一輪排序結束后，最大值的位置已經移動最右端，再次如此循環，最終經過n-1次則完成最終排序。
使用java算法表示外部循環，需要經過n-1次。即
for(int i=0;i<n-1;i++)
內部循環由于外部循環每完成一次就有一個數字完成最終排序，則需要經過n-1-i次比較
for(int j=0;j<n-1-i;j++)
最終冒泡排序的java算法為：
int[] a=new int[]{18,19,5,8,3};int n=a.length;for(int i=0;i<n-1;i++){for(int j=0;j<n-1-i;j++){if(a[j]>a[j+1]){int temp=a[j+1];a[j+1]=a[j];a[j]=temp;}}}for(int k=0;k<n;k++){System.out.println("**"+a[k]);}
?
2.快速排序
?思路：基于分治的思想，是冒泡排序的改進版。首先在數組中選擇一個基準點，然后從數組的兩端開始掃描，設置lo指標指向開始端，hi指向結尾端。
從后半部分開始掃描，如果掃描到有比基準點值小的，則把這個值賦值給基準點位置。然后從前部分掃描，掃描比基準點大的元素，掃描到后把該元素賦值與上一個移動的元素。
如此循環，直到lo，hi指針重合，則結束一輪循環。這次把基準點的值賦值給最后一個變動的元素，這時，基準點前面都是比它小的元素，后面都是比它大的，也就是是確定了基準點的最終位置。
排序過程如下：
原始數據 ? ? ?72 ? 6 ? 57 ? ? 83 ? ? 42 ? ?34 ? ?81 ? ? 12 ? ? ?29 ? ? ? ?{72 設置為基準點，lo指向開始，hi指向結尾。從后面掃描，發現29<72 把29賦值為72}
現在數據 ? ? ?29 ? 6 ? 57 ? ? 83 ? ? 42 ? ?34 ? ?81 ? ? 12 ? （29） ? ? ?{從前面掃描，找比72大的，掃描到83，則把83賦值給（29）處}
現在數據 ? ? ?29 ? 6 ? 57 ?（83） ?42 ? ?34 ? ?81 ? ? 12 ? ? ? 83 ? ? ? ?{從后面掃描，找比72小的，發現12，將12賦值給(83)}
現在數據 ? ? ?29 ? 6 ? 57 ? ? 12 ? ? 42 ? ?34 ? ?81 ? ?(12) ? ? 83 ? ? ? ?{ 從前面掃描，找比72大的，發現81，把81賦值給(12)}
現在數據 ? ? ?29 ? 6 ? 57 ? ? 12 ? ? 42 ? ?34 ? (81) ? ?81 ? ? ?83 ? ? ? ? {hi ?lo 重合，基準點72賦值給(81)，完成一次循環}
一輪數據 ? ? ?29 ? 6 ? ?57 ? ?12 ? ? 42 ? ?34 ? ? 72 ? ? 81 ? ? ?83 ? ? ? ?{基準點的最終位置確定}
其過程圖如下:
其算法實現找到基準點位置：需要定義lo，hi
?
private int partition(int sortArray[],int low,int hight){/*** key 值為基準點的值 */int key = sortArray[low];while(low<hight){/*** 從后半部分開始掃描，大于key的，hi直接-1，如果小于key，則把該元素賦值給array[lo];*/while(low<hight && sortArray[hight]>=key)hight--;sortArray[low] = sortArray[hight];/*** 從前半部分掃描，小于key的，lo直接+1，如果大于key，則把該元素賦值給array[hi];*/while(low<hight && sortArray[low]<=key)low++;sortArray[hight] = sortArray[low];}/*** 然后lo hi重合時，結束，把key賦值給array[lo]即可*/sortArray[low] = key;return low;}
到此找到基準點的最終位置，然后以基準點現在位置，分為左右兩部分，在循環上面的操作
public void sort4(int[] data,int low,int hight){if(low<hight){int result = partition(data,low,hight);sort4(data,low,result-1);sort4(data,result+1,hight);}}
?
?
?
)
