算法排序專題

歸併排序（nlogn）

public class MergeSort {   
    public static int[] mergeSort(int[] nums, int l, int h) {
        if (l == h)
            return new int[] { nums[l] };
         // int mid=(l+r)>>>2; 它會出現棧溢出
        int mid=(l+r)>>>1;    //往低位移1位是/2，移2位是/4
        int[] leftArr = mergeSort(nums, l, mid); //左有序數組
        int[] rightArr = mergeSort(nums, mid + 1, h); //右有序數組
        int[] newNum = new int[leftArr.length + rightArr.length]; //新有序數組
         
        int m = 0, i = 0, j = 0; 
        while (i < leftArr.length && j < rightArr.length) {
            newNum[m++] = leftArr[i] < rightArr[j] ? leftArr[i++] : rightArr[j++];
        }
        while (i < leftArr.length)
            newNum[m++] = leftArr[i++];
        while (j < rightArr.length)
            newNum[m++] = rightArr[j++];
        return newNum;
    }
    public static void main(String[] args) {
        int[] nums = new int[] { 9, 8, 7, 6, 5, 4, 3, 2, 10 };
        int[] newNums = mergeSort(nums, 0, nums.length - 1);
        for (int x : newNums) {
            System.out.println(x);
        }
    }
}

堆排（nlogn）

public class HeapSortTest {
    @Test
    public void run()
    {
        int a[]={5,3,7,2,4,6};
        heap_sort(a,6);
        for (int b:a){
            System.out.println(b);
        }
    }
    /**
     * 從下往上，從右往左，一次找到父節點，然後進行堆化
     */
    void build_heap(int tree[],int n){
        int last_node=n-1;
        int parent=(last_node-1)/2;
        int i;
        for(i=parent;i>=0;i--){
            heapify(tree,n,i);
        }
    }
    //heapify----堆化，堆調整，的意思
    void heapify(int tree[],int n,int i){
        /**
         * 是否滿足大頂堆的順序，逆序則交換
         */
        if (i>=n){
            return;
        }
        int c1=2*i+1;
        int c2=2*i+2;
        int max=i;
        if (c1<n&&tree[c1]>tree[max]){
            max=c1;
        }
        if (c2<n&&tree[c2]>tree[max]){
            max=c2;
        }
        if (max!=i){
            swap(tree,max,i);
            heapify(tree,n,max);
        }
    }
    void swap(int tree[],int i,int j){
        int temp=tree[i];
        tree[i]=tree[j];
        tree[j]=temp;
    }
    void heap_sort(int tree[],int n){
        build_heap(tree,n);
        int i;
        for (i=n-1;i>=0;i--){
            swap(tree,i,0);  //交換+剪短
            heapify(tree,i,0);  //調整堆，使堆常保持大頂堆的姿態。
        }
    }
}
//輸出結果：2,3,4,5,6,7

快排（nlogn）

if（左右指針參數合法&&左指針<右指針）{ //否則直接結束
首先定義5個變量，low和start記錄左指針位置，high和end記錄右指針位置，base記錄基數值
然後遍歷數組【只要左指針<右指針，就一直遍歷數組】，假設每輪都選定數組首元素做爲基數。先將右指針從右往左移，遇到比基數小於或等於的數就停下來（或左指針和右指針相遇），交換他和基數的位置。接着將左指針從左往右移，遇到比基數大於或等於的就停下來（或左指針和右指針相遇），交換當前它和右指針的位置。最後將基數填到當前右指針的位置處（基數歸位）。
然後再遞歸對左邊的進行排序，再遞歸的對右邊的進行排序。
==注意：==while裏面的判斷條件和我們日常的描述是相反的

代碼如下：

 public static void quicksort(int arr[], int left, int right) {
        if (left >= 0 && right <= arr.length - 1 && left < right) {
            int low = left;
            int hight = right;
            int base = arr[left];   //因爲我選的哨兵位是最左邊，所以這就決定了首次進行逆序交換的一定是比基數小的，也就是說 必須先交換右邊的，才能再交換左邊的。
            while (left < right) {
                while (left < right && arr[right] >= base) right--;
                arr[left] = arr[right];
                while (left < right && arr[left] <= base) left++;
                arr[right] = arr[left];
            }
            arr[right] = base;
            quicksort(arr, low, left - 1);
            quicksort(arr, left + 1, hight);
        }

    }


//測試
public static void main(String[] args) {
            int[] nums = new int[] { 9, 8, 7, 6, 5, 4, 3, 2, 10 };
            int[]  a=quicksort(nums,0,nums.length-1);
            for (int x:a){
                System.out.println(x);
            }
        }

GIF動圖演示各種排序算法

GIF動圖演示各種排序算法