算法從小白到大神之荷蘭國旗問題&快排&堆排

題目一：

給定一個數組arr，和一個數num，請把小於等於num的數放在數 組的左邊，大於num的數放在數組的右邊。
要求額外空間複雜度O(1)，時間複雜度O(N)
問題二（荷蘭國旗問題）
給定一個數組arr，和一個數num，請把小於num的數放在數組的 左邊，等於num的數放在數組的中間，大於num的數放在數組的 右邊。
要求額外空間複雜度O(1)，時間複雜度O(N)

/**
 * 問題:（荷蘭國旗問題）
 * 給定一個數組arr，和一個數num，請把小於num的數放在數組的 左邊，等於num的數放在數組的中間，大於num的數放在數組的 右邊。
 * 要求額外空間複雜度O(1)，時間複雜度O(N)
 */
public class NetherLandsFlag {
    public static int[] partition(int [] arr,int L,int R,int num){
        int less=L-1;
        int more=R+1;
        int cur=L;
        while (cur<more){
            if (arr[cur]<num){
                swap(arr,++less,cur++);
            }else if(arr[cur]>num){
                swap(arr,--more,cur);
            }else {
                cur++;
            }
        }
        return arr;
    }

    private static void swap(int[] arr, int i, int j) {
        arr[i]=arr[i]^arr[j];
        arr[j]=arr[i]^arr[j];
        arr[i]=arr[i]^arr[j];
    }
    public static int [] generateArray(){
        int [] arr=new int[10];
        for (int i = 0; i < arr.length; i++) {
            arr[i]=(int)(Math.random()*3);
        }
        return arr;

    }

    public static void main(String[] args) {
        int [] arr=generateArray();
        int[] res=partition(arr,0,arr.length-1,2);
        System.out.println(Arrays.toString(res));
    }
}

題目二：

隨機快速排序的細節和複雜度分析
能夠用荷蘭國旗問題來改進快速排序
時間複雜度O(N*logN)，額外空間複雜度O(logN)

/**
 * 快排
 */
public class QuickSort {
    public static void quickSort(int [] arr){
        if (arr==null || arr.length<2){
            return;
        }
        quickSort(arr,0,arr.length-1);
    }

    private static void quickSort(int[] arr, int L, int R) {
        if (L<R){
            int [] p=partition(arr,L,R);
            quickSort(arr,L,p[0]-1);
            quickSort(arr,p[1]+1,R);
        }
    }

    private static int[] partition(int[] arr, int L, int R) {
        int less=L-1;
        int more=R;
        int cur=L;
        while (cur<more){
            if (arr[cur] < arr[R]) {
                swap(arr,++less,cur++);
            }else if(arr[cur]> arr[R]){
                swap(arr,--more,cur);
            }else {
                cur++;
            }
        }
        swap(arr,more,R);
        return new int[]{less+1,more};
    }

    private static void swap(int[] arr, int i, int j) {
        int tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }

    public static void main(String[] args) {
        int [] arr={12,10,4,10,10,8,9,10};
        quickSort(arr);
        System.out.println(Arrays.toString(arr));
    }
}

題目三
堆排序的細節和複雜度分析
時間複雜度O(N*logN)，額外空間複雜度O(1)
堆結構很是重要

1，堆結構的heapInsert與heapify

2，堆結構的增大和減小

3，若是隻是創建堆的過程，時間複雜度爲O(N)

4，優先級隊列結構，就是堆結構

/**
 *  堆排
 */
public class HeapSort {
    public static void heapSort(int[] arr) {
        if (arr == null || arr.length < 2) {
            return;
        }
        for (int i = 0; i < arr.length; i++) {
            heapInsert(arr, i);
        }
        int size = arr.length;
        swap(arr, 0, --size);
        while (size > 0) {
            heapify(arr, 0, size);
            swap(arr, 0, --size);
        }
    }

    public static void heapInsert(int[] arr, int index) {
        while (arr[index] > arr[(index - 1) / 2]) {
            swap(arr, index, (index - 1) / 2);
            index = (index - 1) / 2;
        }
    }

    public static void heapify(int[] arr, int index, int size) {
        int left = index * 2 + 1;
        while (left < size) {
            int largest = left + 1 < size && arr[left + 1] > arr[left] ? left + 1 : left;
            largest = arr[largest] > arr[index] ? largest : index;
            if (largest == index) {
                break;
            }
            swap(arr, largest, index);
            index = largest;
            left = index * 2 + 1;
        }
    }

    public static void swap(int[] arr, int i, int j) {
        int tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }

    public static void main(String[] args) {
        int []arr={1,34,4,5,76,8,9};
        heapSort(arr);
        System.out.println(Arrays.toString(arr));
    }
}

有關排序問題的補充：

1，歸併排序的額外空間複雜度能夠變成O(1)，可是很是難，不 須要掌握，能夠搜「歸併排序 內部緩存法」

2，快速排序能夠作到穩定性問題，可是很是難，不須要掌握， 能夠搜「01 stable sort」

3，有一道題目，是奇數放在數組左邊，偶數放在數組右邊，還 要求原始的相對次序不變，碰到這個問題，能夠懟面試官。面試官非良人。

參考：牛客算法進階