分治の归并排序

最新推荐文章于 2024-08-02 18:52:04 发布

「已注销」

最新推荐文章于 2024-08-02 18:52:04 发布

阅读量56

点赞数 1

分类专栏： java算法文章标签： java 排序算法

本文链接：https://blog.csdn.net/m0_66254684/article/details/129392079

版权

java算法专栏收录该内容

1 篇文章 0 订阅

订阅专栏

import java.util.Arrays;

/**
 * Created with IntelliJ IDEA.
 *
 * @Author: Tired_cxx
 * @Date: 2023/03/07/19:21
 * @Description: 分治の归并排序
 * <p>
 * 归并排序实际是由两部分组成:
 * 1 分:是用递归求数组的最大值(或最小值)[取决于你怎么排序]
 * 2 治:创建一个临时数组，将递归的问题规模合并成一个有序数组
 */
public class trash {
    public static void main(String[] args) {
        int[] arr = {1,3,5,7,2,4,6};
        recursion(arr, 0, arr.length - 1);
        System.out.println("After mergeSort: " + Arrays.toString(arr));
    }
    //recursion:  分:递归划分问题规模
    public static void recursion(int[] arr, int l, int r) { //将需要排序的数组传进来，l代表左边界，r代表右边界
        if (l == r) return; //递归的边界条件，当问题规模细分到只有一个元素时，不用继续递归下去，直接return返回上一个递归，进行归并操作
        int mid = l + ((r - l) >> 1);//mid代表左右边界的中间索引，因为递归在进行划分问题规模，这里类似于二分查找，每一次递归将问题规模分成两份。
        recursion(arr, l, mid); //左边的问题规模进行递归划分，直到递归划分到边界条件
        recursion(arr, mid + 1, r);//右边的问题规模进行递归划分，直到递归划分到边界条件
        merge(arr, l, mid, r);   //将左右问题规模进行  “治”
    }

    //merge:  治:对每一次递归划分出来的问题规模进行排序处理
    private static void merge(int[] arr, int l, int mid, int r) {
        int[] helper = new int[r - l + 1];  //用二路归并将传进来的 递归划分后的问题规模进行排序操作，存放在helper数组中。
        int helperIndex = 0;
        int pointL = l;  //pointL 指向 递归划分的左边问题规模 的 左边界
        int pointR = mid + 1;  //pointR指向 递归划分的右边问题 规模的 左边界

        /*
         * 刚才说了，helper数组存放左右问题规模的排序内容，
         * 也就是说，左边问题规模从左边界l开始(pointL),右边那一部分问题规模从mid+1(pointR)开始
         * 这里的排序规则是从小到大排序，所以左边问题规模指针(pointL)指向的元素如果小于右边问题规模指针(pointR)指向的元素，
         * 就将arr[pointL++] 放入helper数组中
         * 上面while的循环条件说的是，左右两个问题规模不停进行元素比较，谁先越界，就说明它元素全按照顺序
         * 存入了helper数组，另外一个问题规模的剩下的元素肯定都比helper中现有的大
         * 为什么？？？？？？？？
         * 为什么两个问题规模的比较默认都已经排好序了？？？？？
         * 因为递归的边界条件:最先进行merge的递归左右两个问题规模:左边问题规模 一个元素，右边问题规模也为 一个元素
         * 因为排序最少也要2个元素比较才有意义啊
         * 归并排序的实质就是每一merge操作都将 排序结果得以保留，使得回溯出去的递归能够get到之前递归+归并后的排序结果
         * 而不是像选择排序，冒泡排序每一次比较，并没有将排序结果进行保留记忆。
         */
        while (pointL <= mid && pointR <= r)helper[helperIndex++] = arr[pointL] <= arr[pointR] ? arr[pointL++] : arr[pointR++];
        while (pointL <= mid) helper[helperIndex++] = arr[pointL++];
        while (pointR <= r) helper[helperIndex++] = arr[pointR++];


        /* 这里为什么是l+i?
         * 因为递归进行划分后的问题规模是将这个数组进行划分，传进来的l,mid,和r都是相对而言的
         * 传进来的l有可能是4 (arr[4]) ,mid 是5 (arr[5]) ,r是6 (arr[6])
         * 而helper数组每次都是根据问题规模定义的大小
         * 比如第一次helper数组长度是2 : 就是左边问题规模1个元素，右边问题规模1个元素
         * 回溯后第一次 helper数组的长度就是4了(看图) :就是左边问题规模是已经排好序的2个，右边问题规模也是排好序的2个*/
        for (int i = 0; i < helper.length; i++) {
            arr[l + i] = helper[i];
        }
    }
}