归并排序和基数排序

1、归并排序

1.1、归并排序基本介绍和思想

• 归并排序(MERGE-SORT）是利用归并的思想实现的排序方法，该算法采用经典的分治(divide-and-conquer）策略（分治法将问题分(divide)成一些小的问题然后递归求解，而治(conquer)的阶段则将分的阶段得到的各答案"修补"在一起，即分而治之)。

• 归并排序思想示意图1-基本思想:
  

  • 说明：可以看到这种结构很像一棵完全二叉树，本文的归并排序采用递归去实现（也可采用迭代的方式去实现）。分阶段可以理解为就是递归拆分子序列的过程。

• 归并排序思想示意图2-合并相邻有序子序列:

  • 治阶段，需要将两个已经有序的子序列合并成一个有序序列，比如上图中的最后一次合并，要将[4,5,7,8]和[1,2,3,6]两个已经有序的子序列，合并为最终序列[1,2,3,4,5,6,7,8]，来看下实现步骤
    

1.2、归并排序代码实现

public class MergeSort {
    public static void main(String[] args) {
        int[] arr = {8, 4, 5, 7, 1, 3, 6, 2};
        int[] temp = new int[arr.length]; //归并排序需要一个额外空间
        mergeSort(arr, 0, arr.length - 1, temp);
        System.out.println("归并排序后=" + Arrays.toString(arr));
    }

    //分+合的方法
    public static void mergeSort(int[] arr, int left, int right, int[] temp) {
        if (left < right) {
            int mid = (left + right) / 2; //中间索引
            //向左递归进行分解
            mergeSort(arr, left, mid, temp);
            //向右递归进行分解
            mergeSort(arr, mid + 1, right, temp);

            //合并
            merge(arr, left, mid, right, temp);
        }
    }

    //合并的方法
    /**
     * @param arr   排序的原始数组
     * @param left  左边有序序列的初始索引
     * @param mid   中间索引
     * @param right 右边索引
     * @param temp  做中转的数组
     */
    public static void merge(int[] arr, int left, int mid, int right, int[] temp) {
        System.out.println("xxxxx");
        int i = left; //初始化 i 左边有序序列的初始索引
        int j = mid + 1; //初始化 j 右边有序序列的初始索引
        int t = 0; //指向temp数组的当前索引

        //1.先把左右两边（有序）的数据按照规则填充到temp数组，直到左右两边的有序序列，有一边处理完毕为止
        while (i <= mid && j <= right) { //继续
            //如果左边的有序序列的当前元素，小于等于右边的有序序列的当前元素,则将左边的当前元素，拷贝到temp数组
            //然后t++,i++
            if (arr[i] <= arr[j]) {
                temp[t] = arr[i];
                t++;
                i++;
            } else {//反之，将右边有序序列的当前元素，填充到temp数组
                temp[t] = arr[j];
                t++;
                j++;
            }
        }

        //2. 把有剩余数据的一边的数据一次全部填充到temp
        while (i <= mid) { //左边的有序序列还有剩余的元素，就全部填充到temp
            temp[t] = arr[i];
            t++;
            i++;
        }
        while (j <= right) { //右边的有序序列还有剩余的元素，就全部填充到temp
            temp[t] = arr[j];
            t++;
            j++;
        }

        //3.将temp数组的元素拷贝到arr
        //注意并不是每次到拷贝所有
        t = 0;
        int tempLeft = left;
        //第一合并时 tempLeft = 0,right = 1;
        //第二合并时 tempLeft = 2,right = 3;
        //第三合并时 tempLeft = 0,right = 3;
        //第四合并时 tempLeft = 4,right = 5;
        //第五合并时 tempLeft = 6,right = 7;
        //第六合并时 tempLeft = 4,right = 7;
        //最后一次（no.7）合并时 tempLeft = 0,right = 7;
        System.out.println("tempLeft="+tempLeft+" right="+right);
        while (tempLeft <= right) {
            arr[tempLeft] = temp[t];
            t++;
            tempLeft++;
        }
    }
}

2、基数排序

2.1、基数排序基本介绍和思想

• 基数排序(radix sort）属于“分配式排序”(distribution sort），又称“桶子法”(bucket sort）或bin sort，顾名思义，它是通过键值的各个位的值，将要排序的元素分配至某些“桶”（数组）中，达到排序的作用

• 基数排序法是属于稳定性（相同数字排序后先后顺序不变）的排序，基数排序法的是效率高的稳定性排序法

• 基数排序(Radix Sort)是桶排序的扩展

• 基数排序是1887年赫尔曼.何乐礼发明的。它是这样实现的：将整数按位数切割成不同的数字，然后按每个位数分别比较。

• 基数排序基本思想

  • 将所有待比较数值统一为同样的数位长度，数位较短的数前面补零。然后，从最低位开始，依次进行一次排序。这样从最低位排序一直到最高位排序完成以后,数列就变成一个有序序列。

• 下面看一个图文解释，理解基数排序的步骤（最大为百位，需3轮）
  

• 基数排序的说明:

  • 基数排序是对传统桶排序的扩展，速度很快.
  • 基数排序是经典的空间换时间的方式，占用内存很大，当对海量数据排序时，容易造成OutOfMemoryError （内容溢出）
  • 基数排序是稳定的。【注:假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[k]之前，则称这种排序算法是稳定的；否则称为不稳定的】
  • 有负数的数组，不用基数排序来进行排序，如果要支持负数，参考：https://code.i-harness.com/zh-CN/q/e98fa9

2.2、基数排序代码实现

//基数排序
public class RadixSort {
    public static void main(String[] args) {
        int[] arr = {53,3,542,748,14,214};
        radixSort(arr);
    }

    //基数排序方法
    public static void radixSort(int[] arr){

        //1.得到数组中最大的数的位数
        int max = arr[0] ;//假设第一个数就是最大数
        for (int i = 0; i < arr.length; i++) {
            if(arr[i]>max){
                max = arr[i];
            }
        }
        //得到最大数是几位数
        //String.valueOf(max).length()
        int maxLength = (max+"").length();

        //定义一个二维数组，表示10个桶，每个桶就是一个一维数组
        //说明
        //1.二维数组包含10个一维数组
        //2.为了防止放入数的时候，数据溢出，则每个一维数组（桶），大小定位arr.length
        //3.很明确，基数排序是使用空间换时间的经典算法
        int[][] bucket = new int[10][arr.length];

        //为了记录每个桶中，实际存放了多少个数据，定义一个一维数组记录各个桶每次放入的数据个数
        //bucketElementCounts[0] ,记录的就是是 bucket[0] 桶的放入数据的个数
        int[] bucketElementCounts = new int[10];

        for (int i = 0,n=1; i < maxLength; i++,n*=10) {
            //针对每个元素的对应位进行排序处理，第一次是个位，第二位是十位，第三次是百位
            for (int j = 0; j < arr.length; j++) {
                //取出每个元素的对应位的值
                int digitOfElement = arr[j] /n % 10;
                //放到对应的桶中
                bucket[digitOfElement][bucketElementCounts[digitOfElement]] = arr[j];
                bucketElementCounts[digitOfElement]++;
            }
            //按照这个桶的顺序（一维数组的下标依次取出数据，放入原来数组）
            int index = 0;
            //遍历每一个桶，并将桶中的数据放入原数组
            for (int k = 0; k < bucketElementCounts.length; k++) {
                //如果桶中有数据，才放入到原数据
                if(bucketElementCounts[k] != 0){
                    //循环该桶，即第k个桶（即第k个一维数组），放入
                    for (int l = 0; l < bucketElementCounts[k]; l++) {
                        //取出元素放入到arr
                        // arr[index++] = bucket[k][l];
                        arr[index] = bucket[k][l];
                        index++;
                    }
                }
                //第i+1轮处理后，需要将每个bucketElementCounts[k] 置0 ！！！！
                bucketElementCounts[k] = 0;
            }
            System.out.println("第"+(i+1)+"轮，对个位的排序处理 arr="+ Arrays.toString(arr));
        }
    }
}