算法篇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;
        }

    }