算法篇4：荷蘭國旗問題優化經典快排

一：經典快排請參考《算法篇1：排序算法（上篇）》

荷蘭國旗問題：

給定一個數組arr ，和一個數num ，請把小於num的數放到數組的左邊，等於num的數放在數組得到中間，大於num的數放在數組的右邊。（要求額外空間復雜度O(1),時間復雜度O(N)）

解題思路：我們用三個指針，第一個 less 指向數組的最左邊減一，表示小於 num 的位置，第二個 more 指向數組最右邊加一，表示大於num的位置，再定義一個指針 cur 在數組中與 num 進行比較，初始位置指向 0，如果 cur指向的值小於 num ，交換 less 的下一個位置與 cur 所指向的數，less 前進一個位置，cur 指向的值等於，則不做變化，cur 指向下一個位置，如果 cur 指向大於 num ，交換 cur 與more 的前一個位置，依次比較到 cur 與more 重合。 

代碼實現：

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

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

　　我們就可以使用這個思路來優化經典快排的方法，經典快排每次只是找到一個數的正確位置

　　但是我們需對上述代碼進行改進，因為快排時我們一般選取最后一個數作為參考數，當在荷蘭問題時，我們就直接將最后一個數放在 more 內，不讓其與其他進行比較交換即可。

代碼實現如下：

　　

    public 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);
        }
    }

    public static int[] partition(int[] arr, int l, int r) {
        int less = l - 1;
        int more = r;
        while (l < more) {
            if (arr[l] < arr[r]) {
                swap(arr, ++less, l++);
            } else if (arr[l] > arr[r]) {
                swap(arr, --more, l);
            } else {
                l++;
            }
        }
        swap(arr, more, r);
                //返回相等區域的下標
        return new int[] { less + 1, more };
    }

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

 

利用這種方法還有問題嗎？其實快速排序本身就存在着弊端，當數組原本有序時，大於和小於區域划分的大小差別不一致，這是復雜度就會增加，那還有辦法優化嗎？

其實我們可以隨機找一個數，這種算法叫做隨機快排，這種算法的復雜度是O（n log n ）這樣就更快了一些。

實現：將此行代碼加入到    if (l < r) {}內，只是相當於隨機選一個位置與最后一個數換下來，這樣不至於在原本有序的情況下復雜度過高。

swap(arr, l + (int) (Math.random() * (r - l + 1)), r);     

 二：比較器

　　我們在工程中，一般進行比較時，大都是對對象進行比較排序，如果直接將對象丟在數組里，調用數組的Arrays.sort(數組)，此時只是對數組中每個對象的內存地址進行排序，那么排出的將毫無意義。我們如果想根據對象的某一個屬性進行排序，我們這時就必須要自定義比較器。

代碼實例：

public class Comparator {
    //模擬定義學生對象
    public static class Student {
        public String name;
        public int id;
        public int age;

        public Student(String name, int id, int age) {
            this.name = name;
            this.id = id;
            this.age = age;
        }
    }
    public static void main(String[] args) {
//實例化對象
        Student student1 = new Student("A", 1, 23);
        Student student2 = new Student("B", 2, 21);
        Student student3 = new Student("C", 3, 22);

        Student[] students = new Student[] { student3, student2, student1 };
        printStudents(students);

//根據年齡進行排序輸出對象
        Arrays.sort(students, new AgeAscendingComparator());
        printStudents(students);

    }
//自定義比較器
    public static class AgeAscendingComparator implements Comparator<Student> {

        @Override
        public int compare(Student o1, Student o2) {
            return o1.age - o2.age;
        }

    }