左神算法第二节课：排序（快排、堆排、桶排、计数与基数排序简单介绍）、荷兰国旗问题、大根堆小根堆，排序稳定性，比较器，相邻两数的最大差值问题

第二节课

排序（快排、堆排、桶排、计数与基数排序简单介绍）
荷兰国旗问题
大根堆小根堆
排序稳定性
比较器
相邻两数的最大差值问题

1. 题目一：

给定一个数组arr，和一个数num，请把小于等于num的数放在数组的左边，大于num的数放在数组的右边。

要求：时间复杂度O(N)、额外空间复杂度O(1)

该问题同荷兰国旗问题，见下：

2. 题目二：

荷兰国旗问题：

给定一个数组arr，和一个数num，请把小于num的数放在数组的左边，等于num的数放在数组的中间，大于num的数放在数组的右边。

要求时间复杂度为O(N)、额外空间复杂度为O(1)。

分析：三个指针法：一个指向前头less，一个指向尾部more，一个是当前下标cur。当前下标由指向前面的指针推着前进。

代码如下：

    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) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

3. 快排

根据荷兰国旗问题，变形，让num=arr[arr.length-1]，相当于R= arr.length-2;

经典快排缺点：如[1,2,3,4,5,6,7…N]，快排就成了O(N²)；

改进：随机快排：即是选择num = arr[]中随机的元素。时间复杂度O(N*logN)；额外空间复杂度O(logN)；【最常用的】

非随机代码如下：

    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], R);
        }
    }

    public 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) {
        // TODO Auto-generated method stub
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;        
    }

随机快排代码如下：

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

    public static void quickSort(int[] arr, int l, int r) {
        if (l < r) {
            swap(arr, l + (int) (Math.random() * (r - l + 1)), 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;
    }

4. 堆排序

时间复杂度O(N*logN)，额外空间复杂度O(1)

【堆结构非常重要】

堆结构的heapInsert和heapify；
堆结构的增大和减少；
如果只是建立堆的过程，时间复杂度为O(N)；
优先级队列结构就是堆结构。

堆： 完全二叉树。每一层从左到右依次补齐，满二叉树属于完全二叉树。

当一个数组满足左：2*i+1，右：2*i+2，父：（i-1）/2就是完全二叉树结构。

大根堆：任何子树的最大值都是子树的根节点，

小根堆：任何子树的最小值都是子树的根节点。

用处：比如实时求所输入数据的中位数。

大根堆的建立：

有任何一个子树变成大根堆。复杂度=log1+ log2+… +logN=O(N)

public class HeapSort {

    public static void heapSort(int[] arr) {
        if (arr.length<2 || arr==null) {
            return;
        }
        for (int i = 0; i < arr.length; i++) {
            heapInsert(arr,i);//建立大根堆；
        }
        int heapSize = arr.length;
        swap(arr, 0, --heapSize);
        while (heapSize>0) {
            heapify(arr,0,heapSize);//调整大根堆
            swap(arr, 0, --heapSize);//将大根堆的根和最后一个元素交换，然后size缩小一个；
        }
    }
    
    private static void heapify(int[] arr, int index, int size) {
        //找到left
        int left = 2*index+1;
        //进行循环
        while (left<size) {
            //确定left和right中较大的位置
            int largest = left+1<size && arr[left+1]<arr[left] ? left : left+1;
            //确定孩子和父节点中较大的位置
            largest = largest>arr[index] ? largest : index;
            //如果最大位置和父节点位置相同，则跳出循环
            if (largest == index) {
                break;
            }
            //否则，交换最大值和父节点的值，将变量更新
            swap(arr, index, largest);
            index = largest;
            left = 2*index+1;
        }
    }

    private static void heapInsert(int[] arr, int index) {//如果插入节点值要比父节点值大，则交换，并且比较下一轮。
        while (arr[index]>arr[(index-1)/2]) {
            swap(arr,index,(index-1)/2);
            index = (index-1)/2;
        }
    }

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

    public static void main(String[] args) {
        // TODO Auto-generated method stub
    }
}

5. 题目三

从一个流中不断生成数，求吐出的数的中位数。

同牛客网剑指OfferDay63

6. 排序的稳定性：

稳定性：排序外，相同元素保持出现的先后顺序。

复杂度是O(N²)

l 冒泡排序：当遇到相同数时，该数不交换，将后面的数往下沉。可以稳定；
l 插入排序：当遇到相同数时，该数不交换；可以稳定；
l 选择排序：做不到稳定性。因为你要从后面的所有数中找到最小的，然后将前面的某一个a与该最值交换，如果有多个a存在，那么，a的先后顺序将无法保证。故做不到。

复杂度是O(N)

l 归并排序：merge时，当相同时先拷贝左边（小区域）的数；可以稳定
l 快排：做不到稳定性；
l 堆排：做不到稳定性。在建大根堆的时候，就都已经不能保证稳定性了。

工程中的排序：

l 基础类型：快排
l 自定义类型：归并排序（稳定性）
l 如果数组长度较短：不管什么类型，都用插排（时间复杂度O(N^2)劣势显示不出来，反而额外空间复杂度O(1)较快）。

7. 比较器：

负数，第一个参数放前面（o1）
正数，第二个参数放前面（o2）
0，一样大

在笔试时候，如果不是考察排序，就直接调用系统的Arrays.sort(arr)即可。或者加上自定义的比较器Arrays.sort(arr，new myComparator())；

l 堆中的比较器

　　　　优先级队列实质上就是堆，分为大根堆，小根堆。

　　　　必须指定排序依据。

TreeMap<T>红黑树结构

以下为非比较的排序（基于桶）

非基于比较的排序，与被排序的样本的实际数据状况很有关系，所以实际中并不经常使用；
时间复杂度O(N)，额外空间复杂度O(N)；
稳定的排序。

8. 桶排序：

词频，桶就是容器，可以是队列，可以是堆等，一个萝卜一个坑，按照数据状况分到每个桶。

题目四

给定一个数组，求如果排序之后，相邻两数的最大差值，要求时间复杂度O(N)，且要求不能用非基于比较的排序。

思路：借用桶的概念，但没有进行桶排序。
先找到最大最小值，若max == min ,则数组中数据全相同，差值最大为0；
若max != min ，N个数，设定N+1个桶，每个桶范围是(max-min)/(N+1)
利用鸽笼问题，总有一个桶是空的，可以排除同一桶内的两个数的差值不是最大的。
记录每个桶内的最大，最小，以及是否进来过数。
给定某值i，以及数组最大最小值max,min和数组长度len，确定该值所在的桶的标号
bid = (int)(i-min)*len/(max-min)，

    public static int maxGap(int[] nums) {
        if (nums == null || nums.length < 2) {
            return 0;
        }
        int len = nums.length;
        int min = Integer.MAX_VALUE;
        int max = Integer.MIN_VALUE;
        for (int i = 0; i < len; i++) {
            min = Math.min(min, nums[i]);
            max = Math.max(max, nums[i]);
        }
        if (min == max) {
            return 0;
        }
        boolean[] hasNum = new boolean[len + 1];
        int[] maxs = new int[len + 1];
        int[] mins = new int[len + 1];
        int bid = 0;
        for (int i = 0; i < len; i++) {
            bid = bucket(nums[i], len, min, max);
            mins[bid] = hasNum[bid] ? Math.min(mins[bid], nums[i]) : nums[i];
            maxs[bid] = hasNum[bid] ? Math.max(maxs[bid], nums[i]) : nums[i];
            hasNum[bid] = true;
        }
        int res = 0;
        int lastMax = maxs[0];
        int i = 1;
        for (; i <= len; i++) {
            if (hasNum[i]) {
                res = Math.max(res, mins[i] - lastMax);
                lastMax = maxs[i];
            }
        }
        return res;
    }

    public static int bucket(long num, long len, long min, long max) {
        return (int) ((num - min) * len / (max - min));
    }