1.冒泡排序

從第一個元素開始依次i與i+1元素相比較，若i元素較大，則交換兩元素。這樣一趟下來最大的元素就到了隊尾,第二趟則從第一個元素比到第n-1個元素,這樣倒數第二個元素就是從第一個到n-1個元素裏最大的。以此類推，經過n-1趟，要比較n-1+n-2+...+1次，故時間復雜度=n*(n-1)/2,為O(n^2).

 1 public class Sort {
 2     public void BubbleSort(int n,int a[]) {
 3         for (int k = n - 1; k > 0; k--) {
 4             for (int
 
 i = 0; i < k; i++) {
 5                 if (a[i] > a[i + 1])
 6               exchange(a,i,i+1);
 7             }
 8         }
 9     }
10 
11     public void exchange(int a[],int i,int j){
12         int temp=a[i];
13         a[i]=a[j];
14         a[j]=temp;
15     }
16 }

public class Main {

    
 
public static void main(String[] args) {
        int N=20;
        int[] a=new int[20];
        System.out.println("排序前");
        for(int i=0;i<N;i++){
            a[i]=(int)(Math.random()*100+1);
            System.out.print(a[i]+"  ");
        }

        Sort sort =new Sort();
        sort.BubbleSort(N,a);

        System.out.println(
 
"\n冒泡排序後");
        for(int i=0;i<N;i++) System.out.print(a[i]+"  ");

    }
}

2.簡單選擇排序

簡單選擇排序就是從第一個元素開始，依次和後面每個元素進行對比，把其中較小的元素暫存，每個元素與這個前面比過的最小元素在進行比較，這樣一輪下來，就知道最小元素了，把它和第一個元素交換，這樣第一個就是最小的了。然後第二趟就是從第二個元素往後，這樣一趟完了第二個元素就是後面n-1個元素裏最小的......這樣一共要進行n-1趟，每i趟比較n-i次，故n-1+n-2+...+1=n*(n-1)/2，故時間復雜度為O(n^2)。簡單選擇排序是不穩定的排序。

public void SimpleSort(int n,int a[]){
    int minIndex;
    for(int i=0;i<n-1;i++){
        minIndex=i;
        for(int j=i+1;j<n;j++){
            if(a[j]<a[minIndex])minIndex=j;
        }
        exchange(a,i,minIndex);
    }
}

1        sort.SimpleSort(N,a);
2         System.out.println("\n排序後");
3         for(int i=0;i<N;i++) System.out.print(a[i]+"  ");

3.快速排序

快速排序就是選擇第一個數作為基準，然後比它小的元素全部放到它的左邊，比它大的元素全部放到右邊，再對左右兩邊遞歸進行這樣的排序，直到等個序列都排完。

編寫程序時需要有兩個索引，類似於首尾的兩個指針。

 1   public void  QuickSort(int a[],int start,int end){
 2         if(start<end) {
 3             int index = getMiddle(a, start, end);
 4             QuickSort(a, 0, index - 1);
 5             QuickSort(a, index + 1, end);
 6         }
 7     }
 8 
 9     private int getMiddle(int a[],int start,int end){
10         int base=a[start];
11         while(start<end){
12             while(end>start&&a[end]>=base) end--;
13             a[start]=a[end];//start++;
14             while(end>start&&a[start]<=base) start++;
15             a[end]=a[start];//end--;
16         }
17         a[start]=base;
18         return start;
19     }

1         sort.QuickSort(a,0,N-1);
2         System.out.println("\n排序後");
3         for(int i=0;i<N;i++) System.out.print(a[i]+"  ");

註：快速排序是通常被認為在同數量級（O(nlog2n)）的排序方法中平均性能最好的。但若初始序列按關鍵碼有序或基本有序時，快排序反而蛻化為冒泡排序。

快速排序是一個不穩定的排序方法。

4.插入排序

插入排序就是依次掃描每個數，把它插到前面的有序隊列裏。從第二個數開始，第一個數就是一個有序隊列。假設要比較第i個數了，那麽就在它前面的序列從後往前掃描，如果那個數比它大的話，就讓它後一個數等於它。依次掃描，等到某個數不大於這個數了，就把這個數插進去。一共進行n-1趟。時間復雜度T(n)=O()

 1   public void InsertSort(int n,int a[]){
 2         int i,j;
 3         int base;
 4         for(i=1;i<n;i++){//i是想往前已經排好的隊列裏插入的那個數
 5             base=a[i];
 6             j=i;
 7             while(j>0&&a[j-1]>base){
 8                     a[j]=a[j-1];
 9                     j--;
10             }
11             a[j]=base;
12         }
13     }

總結：

穩定的：冒泡排序，直接插入排序，歸並排序，基數排序

不穩定：簡單選擇，快速排序，堆排序，希爾排序

java 常見排序方法比較