跟左神学算法2 排序相关

内容：

1、复杂排序

2、排序总结

3、比较器

4、实际问题

注：实现代码为Java

1、复杂排序

说明：关于简单排序(冒泡排序、选择排序、插入排序)  看这里：https://www.cnblogs.com/wyb666/p/10106010.html

复杂排序主要是以下三种：

• 归并排序: 时间复杂度: O(N * logN) 额外空间复杂度: O(N)
• 随机快速排序: 时间复杂度: O(N * logN) 额外空间复杂度: O(logN)
• 堆排序: 时间复杂度: O(N * logN) 额外空间复杂度: O(1)

归并排序：

整体思路：利用归并的思想实现排序，采用经典的分治策略将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序

代码：

public static void mergeSort(int[] arr) {
    if (arr == null || arr.length < 2) {
        return;
    }
    sortProcess(arr, 0, arr.length - 1);
}
        
public static void sortProcess(int[] arr, int L, int R) {
    if (L == R) {
        return;
    }
    int mid = (L + R) / 2; // L和R中点的位置
    sortProcess(arr, L, mid);                // T(N/2)
    sortProcess(arr, mid + 1, R);            // T(N/2)
    merge(arr, L, mid, R);                    // O(N)
    // T(N) = 2*T(N/2) + O(N) => O(N * logN)
}
    
public static void merge(int[] arr, int L, int mid, int R) {
    // merge: sort the array(L to R)
    int[] help = new int[R - L + 1];        // auxiliary array
    int i = 0;
    int p1 = L;
    int p2 = mid + 1;
    while (p1 <= mid && p2 <= R) {
        // if the value of arr[p1] < arr[p2] give value arr[p1] to help[i]
        // else give value arr[p2] to help[i]
        help[i++] = arr[p1] < arr[p2] ? arr[p1++] : arr[p2++];
    }
    // p1p2 must be and only one arrive the boundary
    // give the remain elements of no-arrive boundary's one(p1 or p2) to help 
    while (p1 <= mid) {
        help[i++] = arr[p1++];
    }
    while (p2 <= R) {
        help[i++] = arr[p2++];
    }
    for (i = 0; i < help.length; i++) {
        // give elements of help to arr
        arr[L + i] = help[i];
    }
}

随机快速排序：

快速排序：通过一轮的排序将序列分割成独立的两部分，其中一部分均比另一部分小(根据某个值划分这两个区域)。继续对长度较短的序列进行同样的分割，最后到达整体有序

众所周知，基础快速排序算法，其效率一个关键点就在与划分元素的选取，由于之前一直选取的是第一个元素，所以当遇到特殊输入，比如太大或者太小，就会造成区间划分极度不合理。

引入随机化，就是在每一次划分的时候随机选取一个元素作为关键字，用它来进行划分。由于每一次划分都是随机选取，所以每一次都选到不好的元素概率低，可以作为一个优化的方向

代码：

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使最后一个数随机 减少极限情况的影响(eg: 1 2 3 4 5这样的数组)
        swap(arr, L + (int) (Math.random() * (R - L + 1)), R);
        // 将小于R的数移到左边 大于R的数移到右边 然后R移到中间 返回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) {
        // L表示当前位置
        if (arr[L] < arr[R]) {
            swap(arr, L++, ++less);
        } else if (arr[L] > arr[R]) {
            swap(arr, L, --more);
        } else {
            L++;
        }
    }
        
    swap(arr, more, R);            // 将最后一个数替换到右边界
    // 返回等于区域的左右边界
    return new int[] { less + 1, more };
}

堆排序：

堆排序：将待排序序列构造成一个大顶堆，此时，整个序列的最大值就是堆顶的根节点。将其与末尾元素进行交换，此时末尾就为最大值。然后将剩余n-1个元素重新构造成一个堆，这样会得到n个元素的次小值。如此反复执行，便能得到一个有序序列

堆排序实质上是利用了二叉树 ，实质上在工程中二叉树利用数组结构存储，抽象存储原理如下:
二叉树可以转换成数组: 节点i的左右孩子分别是2*i+1和2*i+2 节点i的父节点是(i-1)/2

大根堆和小根堆:

• 大根堆: 树的任何一个子树的最大值是这颗子树的顶部
• 小根堆: 树的任何一个子树的最小值是这颗子树的顶部

堆排序过程:

• 堆排序实际上就是利用堆结构的排序
• 首先建立一个大根堆(复杂度为O(n)) -> 使用heapInsert插入数
• 然后把大根堆第一个数和最后一个数替换 拿出这个元素把堆的size-1 然后使用heapify对堆进行调整

去掉堆顶的最大数或最小数: 把堆顶(第一个元素)和最后一个元素交换，拿出这个元素然后把堆的size-1，然后对堆顶进行hapify调整

其实优先级队列结构其实就是堆结构

代码：

public static void heapSort(int[] arr){
    if(arr==null||arr.length>2){
        return;
    }
    for(int i=0; i<arr.length; i++){
        heapInsert(arr, i);                    // 初步建立大根堆 0到i
    }
    int heapSize = arr.length;
    swap(arr, 0, --heapSize);                // 第一个和最后一个交换 然后heapSize-1
    while(heapSize>0){
        heapify(arr, 0, --heapSize);
        swap(arr, 0, --heapSize);
    }
}
    
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 heapSize){
    // 拿出堆顶元素之后的调整堆
    int left = index*2+1;
    int right = left+1;
    while(left<heapSize){
        int largest = right<heapSize && arr[right] > arr[left] ? right : left;
        largest = arr[largest] > arr[index] ? largest : index;
        if(largest == index){
            break;
        }
        swap(arr, largest, index);
        index = largest;
        left = index * 2 + 1；
        right = left + 1;
    }
}

2、排序总结

比较少用的排序(了解即可)：

• 桶排序: 时间复杂度O(N) 额外空间复杂度O(N)
• 计数排序: 时间复杂度O(N) 额外空间复杂度O(N)
• 基数排序: 时间复杂度O(N) 额外空间复杂度O(N)
• 上述三种都是非基于比较的排序，与被排序的样本数据实际情况很有关系，在实际中并不常用
• 另外以上三种都是稳定的排序

关于桶排序计数排序基数排序：

桶: 相当于一个容器，可以是数组中的某个位置也可以是双向链表也可以是一个队列也可以是一个堆
    把相应东西放入相应桶内 然后再从低位置的桶依次到高位置 依次把东西倒出来
        
    eg: 数组arr长度为60 数据值为0到60 使用桶排序： 生成一个数组temp长度为61 依次遍历arr得到arr[i]
        将temp对应的数组值++ temp[arr[i]] = temp[arr[i]] + 1 遍历完了之后遍历数组temp输出结果
        每个下标对应几个值就把下标值输出几遍
        实际上这个实例是计数排序 实质上是桶排序的一种实现
        
    基数排序将计数排序进行了改进，用10个桶进行排序 分别针对个位、十位、百位    

算法稳定性：

• 追求算法稳定性的意义: 第一次排序和第二次排序在某些值相等的情况下保持原来的排序顺序
• 冒泡排序: 可以实现稳定(相等的情况下后一个继续往后走)
• 插入排序: 可以实现稳定(相等就不往前插入)
• 选择排序: 做不到稳定
• 归并排序: 可以实现稳定(merge相等的时候就先移动左边的)
• 快速排序: 做不到稳定(partition时做不到)
• 堆排序: 做不到稳定

工程中的综合排序算法(例如Java内置的sort)：

基本思想: 
    数组长度很短(大概小于60)，用插入排序(插入排序常数极低)
    数组长度很长，会先判断里面装的是什么，如果都是基本类型就用快排(不在乎稳定性)，如果都是
        自己定义的类型就用归并排序(在乎稳定性)

3、比较器

什么是比较器：

在使用系统的内置sort时 如果针对的是普通类型 那么会根据普通类型的值来进行排序
但是如果针对的不是普通类型而是自定义类型 这时候就会根据类型对应的对象在内存中的位置进行排序
此时排序就没有任何意义了 但是我们可以写一个自定义的比较器传入给sort使用 让sort使用我们定义的比较器来进行排序

Java中比较器的使用：

// 比较器返回负数表示第一个参数排序时应该放前面
// 比较器返回正数表示第二个参数排序时应该放前面
// 比较器返回0表示两个参数一样大
    
// 比较器
import java.util.*;
    
public class MyComparator {
    
    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 class IdAscendingComparator implements Comparator<Student> {
        // id升序排列
        @Override
        public int compare(Student o1, Student o2) {
            return o1.id - o2.id;
        }
    
    }
        
    public static class IdDescendingComparator implements Comparator<Student> {
        // id降序排列
        @Override
        public int compare(Student o1, Student o2) {
            return o2.id - o1.id;
        }
        
    }
    
    public static class AgeAscendingComparator implements Comparator<Student> {
        // age升序排序
        @Override
        public int compare(Student o1, Student o2) {
            return o1.age - o2.age;
        }
    
    }
    
    public static class AgeDescendingComparator implements Comparator<Student> {
        // age降序排序
        @Override
        public int compare(Student o1, Student o2) {
            return o2.age - o1.age;
        }
        
    }
        
    public static void printStudents(Student[] students) {
        for (Student student : students) {
            System.out.println("Name : " + student.name + ", Id : " + student.id + ", Age : " + student.age);
        }
        System.out.println("===========================");
    }
    
    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);
        
        // 下面的sort不加后面的参数会按照内存中的地址排序
        Arrays.sort(students, new IdAscendingComparator());
        printStudents(students);
    
        Arrays.sort(students, new IdDescendingComparator());
        printStudents(students);
        
        Arrays.sort(students, new AgeAscendingComparator());
        printStudents(students);
        
        Arrays.sort(students, new AgeDescendingComparator());
        printStudents(students);
        
        // 优先队列其实就是个堆
        Comparator comparator = new AgeAscendingComparator();
        Queue<Student> heap = new PriorityQueue<Student>(3, comparator);
        heap.add(student3);
        heap.add(student2);
        heap.add(student1);
        
        System.out.println("优先队列排序: ");
        while(!heap.isEmpty()){
            Student student = heap.poll();        // 弹出堆顶
            System.out.println("Name : " + student.name + ", Id : " + student.id + ", Age : " + student.age);
        }
        
    }
    
}

4、实际问题

小和问题：

问题描述: 
    在一个数组中，每一个数左边比当前数小的数累加起来，叫做这个数组的小和。
    求一个数组的小和。
        例子：    
        [1,3,4,2,5]    
        1左边比1小的数，没有；    
        3左边比3小的数，1；    
        4左边比4小的数，1、3；    
        2左边比2小的数，1；    
        5左边比5小的数，1、3、4、2；    
        所以小和为1+1+3+1+1+3+4+2=16
            
解决思路:
    使用归并排序中的merge将数组分割，然后合并的时候对比大小(如果小就计算)并使合并的整体有序

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

    public static int mergeSort(int[] arr, int L, int R) {
        if (L == R) {
            return 0;
        }
        int mid = L + (R - L) / 2;            // 等同于int mid = (L + R) / 2;
        return mergeSort(arr, L, mid) + mergeSort(arr, mid + 1, R)
                + merge(arr, L, mid, R);
    }

    public static int merge(int[] arr, int L, int mid, int R) {
        int[] help = new int[R - L + 1]; // auxiliary array
        int i = 0;
        int p1 = L;
        int p2 = mid + 1;
        int res = 0;
        while (p1 <= mid && p2 <= R) {
            res += arr[p1] < arr[p2] ? (R - p2 + 1) * arr[p1] : 0;
            help[i++] = arr[p1] < arr[p2] ? arr[p1++] : arr[p2++];
        }
        while (p1 <= mid) {
            help[i++] = arr[p1++];
        }
        while (p2 <= R) {
            help[i++] = arr[p2++];
        }
        for (i = 0; i < help.length; i++) {
            arr[L + i] = help[i];
        }
        return res;
    }

    public static void main(String[] args) {
        int[] arr = { 1, 3, 4, 2, 5 };
        int[] arr2 = { 1 };
        int[] arr3 = { 3, 1 };
        System.out.println(smallSum(arr));
        System.out.println(smallSum(arr2));
        System.out.println(smallSum(arr3));
    }
}

荷兰国旗问题：

荷兰国旗问题
    给定一个数组 arr，和一个数 num，请把小于 num 的数放在数组的左边，等于 num 的数放在数组的中间，大于 num 的数放在数组的右边。
 　　要求额外空间复杂度 O(1)，时间复杂度 O(N)

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, cur++, ++less);
        } else if (arr[cur] > num) {
            swap(arr, cur, --more);
        } else {
            cur++;
        }
    }

    // 返回的是等于区域的左边界和右边界
    if(less+1>more-1){
        // 表示不存在等于区域
        return new int[] { -1, -1 };
    }    
    else{
        // 等于区域存在
        return new int[] { less + 1, more - 1 };
    }
        
}

逆序对问题：

在一个数组中 如果左边的数比右边的数大 则这两个数构成构成一个逆序对 请打印所有逆序对

思路同上面的小和问题

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

    public static void mergeSort(int[] arr, int L, int R) {
        if (L == R) {
            return;
        }
        int mid = L + (R - L) / 2;
        mergeSort(arr, L, mid);
        mergeSort(arr, mid + 1, R);
        merge(arr, L, mid, R);
    }

    public static void merge(int[] arr, int L, int mid, int R) {
        int[] help = new int[R - L + 1];
        int i = 0;
        int p1 = L;
        int p2 = mid + 1;
        while (p1 <= mid && p2 <= R) {
            if (arr[p1] > arr[p2]) {
                System.out.println(arr[p1] + " " + arr[p2]);
            }
            help[i++] = arr[p1] < arr[p2] ? arr[p1++] : arr[p2++];
        }
        while (p1 <= mid) {
            help[i++] = arr[p1++];
        }
        while (p2 <= R) {
            help[i++] = arr[p2++];
        }
        for (i = 0; i < help.length; i++) {
            arr[L + i] = help[i];
        }

    }

    public static void main(String[] args) {
        int[] arr = { 3, 1, 2, 5, 3 };
        ReverseSequence.reverseSequence(arr);
    }
}