从零开始学算法(一)——排序

理解时间复杂度：

一个有序数组A，另一个无序数组B，请打印B中的所有不在A中的数，A数
组长度为N，B数组长度为M。
算法1：对于数组B中的每一个数，都在A中通过遍历的方式找一下；     
算法2：对于数组B中的每一个数，都在A中通过二分的方式找一下；
算法3：先把数组B排序，然后用类似外排的方式打印所有不在A中出现的数；
时间复杂度分别为： O(M*N)， O(M*log(N))，O(M*logM)+O(M+N)  （算法3：排序O(M*logM)，再加上两个有序数组各遍历一遍O(M+N)）

递归的算法的时间复杂度：

递归算法满足 master公式 ：T(N) = aT(N/b)+T(N^d)

其中N是问题的样本量，a是拆分成子问题的数量，N/b是子问题的样本量，N^d是拆分后常规操作的复杂度。

log(b,a)  > d ——> 时间复杂度: O(N^log(b,a))

log(b,a)  = d ——> 时间复杂度: O(N^d*logN)

log(b,a)  < d ——> 时间复杂度: O(N^d))

以归并排序为例，T(N)=2T(N/2)+T(N)，a=2，b=2，d=1；log(1,1)=1,时间复杂度O(N*logN)

排序算法：

1.冒泡排序: 时间复杂度O(N^2),空间复杂度O(1)

相邻两个数比较，大的放在后面。每次遍历把最大的数找出放在最后。

        for(int end=arr.length-1; end > 0; end--){
            for(int i=0;i<end;i++) {
                if (arr[i] > arr[i+1]){
                    swap(arr, i,i+1);
                }
            }
        }

2.选择排序: 时间复杂度O(N^2),空间复杂度O(1)

选出当前最小的数，遍历数组，遇到更小的交换。每次遍历把最小的数找出放在最前面。

        for (int cur = 0; cur<arr.length-1;cur++){
            int minIndex = cur;
            for (int i = cur+1; i <arr.length; i++) {
                minIndex = arr[minIndex]<arr[i]?minIndex:i;
            }
            swap(arr,cur,minIndex);
        }

3.插入排序: 时间复杂度O(N^2)，最好情况O(N) 。空间复杂度O(1)

把当前数插入到前面的有序队列中(类似于玩扑克牌,每摸一张牌，排一次序)。(当原数组越接近所排顺序的时候，时间复杂度越低)

        for (int i = 1; i < arr.length; i++) {
            while (i>0 && arr[i]<arr[i-1]){
                swap(arr,i,i-1);
                i--;
            }
        }

4.归并排序：时间复杂度O(N*logN),空间复杂度O(N)

    public static void mergeSort(int[] arr, int l, int r) {
        if(l==r) {
           return;
        }
        int mid = (l+r)>>1;
        mergeSort(arr,l,mid);     //将左半部分排序
        mergeSort(arr,mid+1,r); //将右半部分排序
        merge(arr,l,mid,r);       //归并排好序的两部分
    }
    
    private static void merge(int[] arr, int l, int m,int r) {
        int[] help = new int[r - l + 1];
        int i = 0;
        int p1 = l;
        int p2 = m + 1;
        //将两个队列依次插入到辅助数组,直到一个队列结束
        while (p1 <= m && p2 <= r) {
            help[i++] = arr[p1] < arr[p2] ? arr[p1++] : arr[p2++];
        }
        //右边队列已到末尾,将左边队列全部插入
        while (p1 <= m) {
            help[i++] = arr[p1++];
        }
        //左边队列已到末尾,将右边队列剩余元素全部插入
        while (p2 <= r) {
            help[i++] = arr[p2++];
        }
        //辅助数组是已排好序,拷贝到原数组
        while(l<=r) {
            arr[r--] = help[--i];
        }
    }

5. 快速排序：平均时间复杂度O(N*logN)，最差情况O(N^2)。空间复杂度O(logN)

    public static void quickSort(int[] arr, int l, int r){
        if(l>=r){
            return;
        }
        //将数组分为3部分:小于区域,等于区域,大于区域
        int[] point = partition(arr,l,r);
        //将小于区域和大于区域排序
        quickSort(arr,l,point[0]);
        quickSort(arr,point[1],r);
    }

    private static int[] partition(int[] arr, int l, int r) {
        //数组中随意取一个值,用来排序
        int num = arr[l+(r-l+1)*(int) Math.random()];
        int less = l-1;
        int more = r+1;

        while (l < more){
            if (arr[l] < num){
                swap(arr,l++,++less);
            }else if(arr[l] == num){
               l++;
            }else {
                swap(arr,l,--more);
            }
        }
        return new int[]{less,more};
    }

6. 堆排序：时间复杂度O(N*logN)，空间复杂度O(1)

 堆结构：把数组想象成完全二叉树的结构，完全二叉树一个节点下标为i，它的左右节点下标分别为2i+1,2i+2，它的父节点下标为(i-1)/2。大(小)根堆就是一棵完全二叉树中，任意一颗子树的最大(小)值都是这颗子树的头部。先建堆，再下沉构成了堆排序，建堆的过程时间复杂度为O(N)

   public static void heapSort(int[] arr){
        if(arr == null || arr.length<2){
            return;
        }
        //先建堆,再下沉
        heapBuild(arr);
        heapSink(arr);
    }

    private static void heapBuild(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            //建堆时,要求满足非叶子节点小于父节点,否则交换位置
            while (arr[i] > arr[(i - 1) / 2]) {
                swap(arr,i,(i - 1) / 2);
                i = (i - 1) / 2;
            }
        }
    }

    private static void heapSink(int[] arr) {
        //下沉时每次把大根堆头部和数组末尾交换位置,heapSize-1
        for (int size = arr.length-1; size>0; size--){
            swap(arr,0,size);
            int index = 0;
            int left = 2*index+1;
            while (left < size){
                int bigger = left+1<size && arr[left+1] > arr[left] ? left+1 : left;
                if(arr[index] >= arr[bigger]){
                   break;
                }
                swap(arr,index,bigger);
                index = bigger;
                left = 2*index+1;
            }
        }
    }