归并排序(merging sort)

归并排序


基本原理

假设初始序列含有n个记录,把他看做n个长度为1的有序子序列。然后两两归并,形成(1+n)/2(不小于n/2的最小整数)个长度为2或1的有序子序列,然后再两两归并,如此循环,直到出现长度为n的有序子序列为止。这种排序称为2路归并排序。

并归算法代码

递归思想去实现

      //递归方式 
      //对顺序表sqlist进行归并排序 
      public void mergingSort(int sqList[]) { 
          MSort(sqList, 0,sqList.length-1);
      }
    /*
     * 分解序列函数(递归方式), 采用递归的方式实现归并排序
     * 
     * @param low is the starting index
     * 
     * @param high is the ending index
     */
    public void MSort(int[] sqList, int low, int high) {

        int mid;
        if (low == high) {
            // 这里只是用来划分子序列
            // 什么都不用做,这时候low=mid=high,要做的事情在merge里面
        } else {
            mid = (low + high) / 2;
            MSort(sqList, low, mid);
            MSort(sqList, mid + 1, high);
            merge(sqList, low, mid, high);
        }
    }
    /*
     * 合并函数 将从low开始到mid的已经有序子的序列 和从mid+1到high的已经有序的子序列 合并成一个有序的序列,还存在原序列sqlist中
     */
    public void merge(int[] sqList, int low, int mid, int high) {
        int i = low;// i是第一个序列的下标
        int j = mid + 1;// j是第二个序列的下标
        int[] array = new int[high - low + 1];// 临时暂存合并后的序列
        int k = 0;// 暂存序列的下标
        while (i <= mid && j <= high) {
            // 判断两个序列哪一个更小,将其存入合并序列,并向下扫描
            if (sqList[i] < sqList[j]) {
                array[k] = sqList[i];
                k++;
                i++;
            } else {
                array[k] = sqList[j];
                k++;
                j++;
            }

        }
        while (i <= mid) {// 如果第一个序列没有扫描完,直接将其接在合并序列后边
            array[k] = sqList[i];
            k++;
            i++;
        }

        while (j <= high) {// 如果第二个序列没有扫描完,直接将其接在合并序列后边
            array[k] = sqList[j];
            k++;
            j++;
        }
        // 将合并的序列复制到原始序列中
        for (i = low, k = 0; i <= high; i++, k++) {
            sqList[i] = array[k];
        }

    }


用循环的思想实现

    public void mergingSort(int sqList[]) {
        for (int gap = 1; gap < sqList.length; gap *= 2) {
            mergePass(sqList, gap, sqList.length);
        }
    }
        /*
     * 循环方式实现分解
     * 
     */
    public void mergePass(int[] array, int gap, int length) {
        int i;
        // 归并gap长度的两个子序列
        for (i = 0; i + 2 * gap - 1 < length; i += 2 * gap) {
            merge(array, i, i + gap - 1, i + 2 * gap - 1);
        }
        // 归并余下的两个子序列,后一个长度小于gap
        if (i + gap - 1 < length) {
            merge(array, i, i + gap - 1, length - 1);// 最后一个元素下标是length-1
        }
    }

    /*
     * 合并函数 将从low开始到mid的已经有序子的序列 和从mid+1到high的已经有序的子序列 合并成一个有序的序列,还存在原序列sqlist中
     */
    public void merge(int[] sqList, int low, int mid, int high) {
        int i = low;// i是第一个序列的下标
        int j = mid + 1;// j是第二个序列的下标
        int[] array = new int[high - low + 1];// 临时暂存合并后的序列
        int k = 0;// 暂存序列的下标
        while (i <= mid && j <= high) {
            // 判断两个序列哪一个更小,将其存入合并序列,并向下扫描
            if (sqList[i] < sqList[j]) {
                array[k] = sqList[i];
                k++;
                i++;
            } else {
                array[k] = sqList[j];
                k++;
                j++;
            }

        }
        while (i <= mid) {// 如果第一个序列没有扫描完,直接将其接在合并序列后边
            array[k] = sqList[i];
            k++;
            i++;
        }

        while (j <= high) {// 如果第二个序列没有扫描完,直接将其接在合并序列后边
            array[k] = sqList[j];
            k++;
            j++;
        }
        // 将合并的序列复制到原始序列中
        for (i = low, k = 0; i <= high; i++, k++) {
            sqList[i] = array[k];
        }

    }

并归算法复杂度

递归方式实现的并归排序的时间复杂度是O(nlogn)
循环方式实现的并归排序的时间复杂度是O(n)

参考文献并归排序

### 归并排序示例题目解析 归并排序是一种经典的分治法排序算法,具有稳定性和 $O(n \log n)$ 的时间复杂度[^1]。以下是几个常见的归并排序应用实例及其解析: #### 力扣第88题 - 合并两个有序数组 此题要求将两个有序数组 `nums1` 和 `nums2` 合并成一个单一的有序数组[^4]。 ##### 思路分析 利用归并排序的核心思想,即比较两个子序列中的最小值并将较小者放入目标位置。具体来说: - 使用双指针分别指向两个数组的起始位置。 - 将较小的元素依次填入新的数组中。 - 如果其中一个数组提前耗尽,则直接复制另一个数组剩下的部分到新数组中。 ##### Python 实现代码 ```python def merge(nums1, m, nums2, n): i, j, k = m - 1, n - 1, m + n - 1 while i >= 0 and j >= 0: if nums1[i] > nums2[j]: nums1[k] = nums1[i] i -= 1 else: nums1[k] = nums2[j] j -= 1 k -= 1 while j >= 0: nums1[k] = nums2[j] j -= 1 k -= 1 ``` --- #### 计算逆序对数量 给定一个整数数组,求出该数组中存在的逆序对的数量(如果满足条件 \(i < j\) 并且 \(arr[i] > arr[j]\),则称为一对逆序对)。可以通过修改标准的归并排序来解决这个问题[^5]。 ##### 思路分析 在每次合并过程中统计当前左侧子数组中大于右侧子数组某个元素的情况总数即可得到局部逆序对数目;最终累加这些局部结果便能得到全局逆序对数目。 ##### Java 实现代码 ```java public class Solution { private int count; public int reversePairs(int[] nums) { this.count = 0; mergeSortCounting(nums, 0, nums.length - 1); return count; } private void mergeSortCounting(int[] nums, int l, int r){ if(l>=r)return ; int mid=l+(r-l)/2; mergeSortCounting(nums,l,mid); mergeSortCounting(nums,mid+1,r); // Count the pairs when merging. int p=mid+1,q=l,sum=0; while(p<=r && q<=mid){ if((long)nums[q]> (long)nums[p]*2 ){ sum +=(mid-q+1); p++; } else{ q++; } } count+=sum; Arrays.sort(nums,l,r+1); } } ``` --- #### 数组区间查询问题 某些场景下可能需要频繁地询问某一段区间的最大/最小值或者总和等问题,在这种情况下可以结合线段树与归并排序共同解决问题[^2]。这里不再展开讨论具体的实现细节,但推荐读者深入研究这两种数据结构如何协同工作以优化性能表现。 ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值