java之最簡單和最複雜的排序算法

1、冒泡排序：

當前元素和next元素對比大小

邏輯單元：

• swap
• 對比次數(i)：每個元素都要對比，直到最後一個不需要(size-1)
• 一輪次數：每一輪都會降低一輪對比的次數(i-j-1)

ok 看看代碼

public class BubleSort {
    public static int[] bubbleSort(int[] arr){
        int size = arr.length;
        for(int i=0;i<size-1;i++){
            for(int j=0;j<size-1-i;j++){
                if(arr[j]>arr[j+1]){
                    swap(arr,j,j+1);
                }
            }
        }
        return arr;
    }


    public static void swap(int arr [],int num1,int num2){
        int temp;
        temp=arr[num1];
        arr[num1]=arr[num2];
        arr[num2]=temp;
    }
    @Test
    public void sort(){
        int arr[]={1,2,3,8,4,5};
        System.out.println(bubbleSort(arr));
    }
}

2、快速排序

1. 找基準值
2. 比大小
3. 交換
4. 繼續查找
5. 交換基準值到合適的位置
6. 重複

快排，排序中據說是最快的(不然爲啥叫做快排呢?)，Arrays.sort()內部實現之一，快排是核心，同時也是分治法得一種

0.測試數據

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

1.找基準值

基準值的問題，大家就先不要糾結，衆說云云，選擇哪個那個是最快的，這裏我就假設第一個爲基準值

這裏基準值就是a[0]=7;

2.比大小

這裏呢，來兩個指針i(數組開始index)和j(結束index)

對比基準值

如果是從小到大呢,則是期望對比結果左邊則是比基準值大的，右邊比基準值小

如果是從大到小則相反

爲什麼是左邊要找基準值大的呢，因爲要交換

知道了期望結果，就知道怎麼做了

3.交換

指針i,j都開始進行靠攏，如果i指針指向的值比基準值小，而j指針執行的值比基準值大，則交換

4.繼續查找

接着i，j繼續靠攏，如果出現符合交換條件的就進行交換，同時也要符合i<j的條件

5.交換基準值到合適的位置

知道i,j指針相遇，則交換基準值

6.重複

接着用分治法的思路，把左邊和右邊分開，繼續進行以上過程(遞歸),最後得到的數組就是從小到大的順序

show 代碼

    public void quickSort(int[]arr,int left,int right)
    {
        if(left>right)
            return;
        int pivot=arr[left];
        int i=left;
        int j=right;
        while(i<j){
            while(arr[i]<pivot&&i<j)
                i++;
            while(arr[j]>pivot&&i<j)
                j--;
            if(i<j){
                swap(arr,i,j);
            }
        }
        arr[left]=arr[i];
        arr[i]=pivot;
        quickSort(arr,left,i-1);
        quickSort(arr,i+1,right);
    }