1.冒泡排序算法：（時間復雜度是n*n）
冒泡排序法是最基本的排序法之一，冒泡排序法的運行機制是通過循環遍歷元素，並調整相鄰元素順序的一種簡單排序方法。 冒泡排序法的運行情況如下（以將數組 {21, 99, 3, 1024, 16} 排列為升序為例）：
（1）冒泡排序法的第一次遍歷目的是將數值最大的元素移動到數組的尾部。首先，將元素21與元素99進行比較，由於21 < 99，所以不用交換元素；其次，將元素99與元素3進行比較，由於99 > 3，所以需要交換元素（即99和3的位置互換，數組的序列被調整為 {21, 3, 99, 1024, 16}）；再次，將元素99與元素1024進行比較，由於99 < 1024，所以也不用交換元素；最后，將元素1024與元素16進行比較，由於1024 < 16，所以需要交換元素（即1024與16的位置互換）。經過第一次遍歷將最大的元素1024調整到了數組的尾部，數組序列變為 {21, 3, 99, 16, 1024}。
（2）冒泡排序法的第二次遍歷與第一次原理一致，只不過第二次遍歷不再關系數組的尾部，因為經過第一次遍歷后，數組的尾部已經存儲了數組中數值最大的元素，所以第二次遍歷的目的是將數組中數值第二大的元素，存儲到數組的倒數第二個位置（即此時只關心數組前四個元素 {21, 3, 99, 16}的順序）。首先，將元素21與元素3進行比較，由於21 > 3，所以需要交換元素（即21和3位置互換，數組的前四位序列被調整為 {3, 21, 99, 16}）；其次，將元素21與元素99進行比較，由於21 < 99，所以不用交換元素；最后，將元素99與元素16進行比較，由於99 > 16，所以需要交換元素（即99和16的位置互換）。經過第二次遍歷數組序列變為 {3, 21, 16, 99, 1024}。
（3）依此類推，第三次遍歷將數組中數值第三大的元素存儲到數組的倒數第三個位置，第四次遍歷將數組中數值第四大的元素存儲到數組的倒數第四個位置，由於數組一共包含五個元素，則排序完成。
實現代碼如下：
int[] test = new int[]{21,99,3,1024,16};
int temp = 0;
for(int i = test.length; i > 0; i--){
for(int j = 0; j < i-1;j++){
if(test[j] > test[j+1]){
temp = test[j];
test[j] = test[j+1];
test[j+1] = temp;
}
}
}
for(int a:test){
System.out.print(a+" ");
}
結果是：
2.選擇排序法：(時間復雜度是n*n)
將要排序的數組分成兩部分，一部分是從大到小已經排好序的，一部分是無序的，從無序的部分取出最小的放到已經排序的最后面。實現如下：
int[] test = new int[]{21,99,3,1024,16};
int temp = 0;
int m ;
System.out.println("原數組是：");
for(int a:test){
System.out.print(a+" ");
}
System.out.println();
for(int i = 0;i < test.length;i++){
m = i;//默認第一個元素最小
for(int j = i+1; j < test.length;j++){
if(test[m] > test[j]){//找到數組中最小的元素，其索引是m
m = j;
}
}
if(m != i){//表明數組沒有排序完畢，交換m和i位置上的元素
temp = test[m];
test[m] = test[i];
test[i] = temp;
}
}
System.out.println("采用選擇排序后的數組是：");
for(int a:test){
System.out.print(a+" ");
}
結果如下：
3..插入排序法：(時間復雜度是n*n)
將要排序的數組分成兩部分，每次從后面的部分取出索引最小的元素插入到前一部分的適當位置。基本實現如下：
int[] test = new int[]{21,99,3,1024,16};
int temp = 0;
int j ;
System.out.println("原數組是：");
for(int a:test){
System.out.print(a+" ");
}
System.out.println();
for(int i = 1;i < test.length;i++){
temp = test[i];
j = i-1;
while(temp < test[j]){
test[j+1] = test[j];
j--;
if(j == -1){
break;
}
}
test[j+1] = temp;
}
System.out.println("采用插入排序后的數組是：");
for(int a:test){
System.out.print(a+" ");
}
結果是：
4..快速排序法：（時間復雜度是n*log(n)）
快速排序法號稱是目前最優秀的算法之一，實現思路是，將一個數組的排序問題看成是兩個小數組的排序問題，而每個小的數組又可以繼續看成更小的兩個數組，一直遞歸下去，直到數組長度大小最大為2。實現如下：
/**
* @param arr-需要排序的數組
* @param low-數組的第一個索引值
* @param high-數組的最后一個索引值
*/
public static void sort(int arr[],int low,int high){
int l=low;
int h=high;
int povit=arr[low];
while(l<h)
{
while(l<h&&arr[h]>=povit)//從右往左找尋比povit小的元素
h--;
if(l<h){//將比povit小的元素放在其左邊
int temp=arr[h];
arr[h]=arr[l];
arr[l]=temp;
l++;
}
while(l<h&&arr[l]<=povit)//從左往右找尋比povit大的元素
l++;
if(l<h){//將比povit大的元素放在其右邊
int temp=arr[h];
arr[h]=arr[l];
arr[l]=temp;
h--;
}
}
for(int a:arr){
System.out.print(a+" ");
}
System.out.print("l="+(l+1)+"h="+(h+1)+"povit="+povit+"\n");
if(l>low)sort(arr,low,l-1);
if(h<high)sort(arr,l+1,high);
}
結果是：
