一.氣泡排序：

外層迴圈控制排序躺數：n個數需要跑n-1躺，一個數組的長度為length，那麼下標為length-1，那麼最大趟數為length-2，即寫為<length-1  //因為比較剩下最後一個數時，無需比較。

內層迴圈控制每一趟的比較次數：每一趟需要比較n-i次

/*
 * 氣泡排序
 */
public class BubbleSort {
　　public static void main(String[] args) {
　　　　int[] arr={6,3,8,2,9,1};
　　　　System.out.println("排序前陣列為：");
　　　　for
 
(int num:arr){
　　　　　　System.out.print(num+" ");
　　　　}
　　　　for(int i=0;i<arr.length-1;i++){//外層迴圈控制排序趟數
　　　　　　for(int j=0;j<arr.length-1-i;j++){//內層迴圈控制每一趟排序多少次
　　　　　　　　if(arr[j]>arr[j+1]){
　　　　　　　　　　int temp=arr[j];
　　　　　　　　　　arr[j]=arr[j+1];
　　　　　　　　　　arr[j+1]=temp;
　　　　　　　　}
　　　　　　}
　　　　} 
　　　　System.
 
out.println();
　　　　System.out.println("排序後的陣列為：");
 　　　　for(int num:arr){
 　　　　　　System.out.print(num+" ");
 　　　　} 
　　}
 }

二.快速排序：

  快速排序，顧名思義，是一種速度快，效率高的排序演算法。
快排原理：
        在要排的數（比如陣列A）中選擇一箇中心值key（比如A[0]），通過一趟排序將陣列A分成兩部分，其中以key為中心，key右邊都比key大，key左邊的都key小，然後對這兩部分分別重複這個過程，直到整個有序。
        整個快排的過程就簡化為了一趟排序的過程，然後遞迴呼叫就行了。
        一趟排序的方法：
1，定義i=0，j=A.lenght-1，i為第一個數的下標，j為最後一個數下標
2，從陣列的最後一個數Aj從右往左找，找到第一小於key的數，記為Aj；
3，從陣列的第一個數Ai 從左往右找，找到第一個大於key的數，記為Ai；
4，交換Ai 和Aj 
5，重複這個過程，直到 i=j
6，調整key的位置，把A[i] 和key交換
假設要排的陣列為：A[8] ={ 5 2 8 9 2 3 4 9 }
           選擇 key = 5， 開始時 i=0，j=7

開始：       5    2    8    9    2    3    4    9
                i                                        j  
第一次找   5    2    8    9    2    3    4    9
                            i                       j
交換：       5    2    4    9    2    3    8    9 
                            i                       j
第二次找   5    2    4    9    2    3    8    9
                                  i           j
交換：       5    2    4    3    2    9    8    9
                                  i            j
第三次找    5    2    4    3    2    9    8    9
                                       ij   
調整key： 2    2    4    3    5    9    8    9
                                        ij

以下為程式碼：

public class QuickSort {
    public static void main(String[] args) {
        int[] a = {1, 2, 4, 5, 7, 4, 5 ,3 ,9 ,0};
        System.out.println(Arrays.toString(a));
        quickSort(a);
        System.out.println(Arrays.toString(a));
    }

    public static void quickSort(int[] a) {
        if(a.length>0) {
            quickSort(a, 0 , a.length-1);
        }
    }

    private static void quickSort(int[] a, int low, int high) {
        //1,找到遞迴演算法的出口
        if( low > high) {
            return;
        }
        //2, 存
        int i = low;
        int j = high;
        //3,key
        int key = a[ low ];
        //4，完成一趟排序
        while( i< j) {
            //4.1 ，從右往左找到第一個小於key的數
            while(i<j && a[j] > key){
                j--;
            }
            // 4.2 從左往右找到第一個大於key的數
            while( i<j && a[i] <= key) {
                i++;
            }
            //4.3 交換
            if(i<j) {
                int p = a[i];
                a[i] = a[j];
                a[j] = p;
            }
        }
        // 4.4，調交換key和零界點的值
        int p = a[i];
        a[i] = a[low];
        a[low] = p;
        //5, 對key左邊的數快排
        quickSort(a, low, i-1 );
        //6, 對key右邊的數快排
        quickSort(a, i+1, high);
    }
}

快速排序的複雜度:

　　最糟糕的情況下, 複雜度為: O(n²)

　　最優的情況下, 複雜度為: O(nlog₂n)

最差情況下, 快速排序和氣泡排序的時間複雜度是O(n²),  但是最優情況下, 氣泡排序是 n * n, 而快速排序的是 n * log₂n,

如果n=16,

則冒泡是 16 * 16

快速排序是 16 * 4

可見, 只要你不是背到家, 都是比冒泡來的快的.

原文：https://blog.csdn.net/Yexiaofen/article/details/78018204?utm_source=copy