【C++】【排序算法】归并排序；并的优化、应用插入排序的优化、额外空间的优化、迭代的归并【手撕排序】

最新推荐文章于 2024-04-30 09:00:00 发布
最新推荐文章于 2024-04-30 09:00:00 发布
阅读量383 收藏 1
点赞数 1
分类专栏： 数据结构与算法 c/c++ 文章标签： 算法 排序算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44503157/article/details/117847496
版权

文章目录

一、归并排序

1. 相关问题

merge操作的同时，可以解决 “逆序对问题”；

2.优劣

如果包含大量重复元素，paitition会分的不平衡，最差情况退化为O(n2)；所以把等于标定点的值均匀分到两边。

相对稳定；即：相同的元素，排之后的次序和排之前的次序一致。

需要额外空间；即：在merge 的过程中，需要使用额外的空间。

3.复杂度分析

空间复杂度为O(n)；

时间复杂度：

因为归并排序递归的将其二分，于是递归的层级就有logn层。具体的是以2为底n的对数。long2 n；

每层递归中，都将n个数据都扫描了一次。例如：第二层递归中，堆left-mid 和mid+1 -right 都扫描了一遍。

最终时间复杂度就为O(nlogn)

二、代码

1.normal

下面是没有经过优化的完全体：

// 将arr[l...mid]和arr[mid+1...r]两部分进行归并
template<typename  T>
void __merge(T arr[], int l, int mid, int r){

    T *aux = new T[r-l+1];

    for( int i = l ; i <= r; i ++ )
        aux[i-l] = arr[i];

    // 初始化，i指向左半部分的起始索引位置l；j指向右半部分起始索引位置mid+1
    int i = l, j = mid+1;
    for( int k = l ; k <= r; k ++ ){

        if( i > mid ){  // 如果左半部分元素已经全部处理完毕
            arr[k] = aux[j-l]; j ++;
        }
        else if( j > r ){  // 如果右半部分元素已经全部处理完毕
            arr[k] = aux[i-l]; i ++;
        }
        else if( aux[i-l] < aux[j-l] ) {  // 左半部分所指元素 < 右半部分所指元素
            arr[k] = aux[i-l]; i ++;
        }
        else{  // 左半部分所指元素 >= 右半部分所指元素
            arr[k] = aux[j-l]; j ++;
        }
    }

    delete[] aux;
}

// 递归使用归并排序,对arr[l...r]的范围进行排序
template<typename T>
void __mergeSort(T arr[], int l, int r){

    if( l >= r )
        return;

    int mid = (l+r)/2;
    __mergeSort(arr, l, mid);
    __mergeSort(arr, mid+1, r);
    __merge(arr, l, mid, r);
}

template<typename T>
void mergeSort(T arr[], int n){

    __mergeSort( arr , 0 , n-1 );
}

2.merge优化+插入排序优化

区别在于

  1. merge之前如果已经发现两段是有序的，就不需要mege了
  2. 对于递归到小数量级的，使用插入排序，速度更佳。这是因为插入排序虽然是0(n2)，但是其常数更小，在n并不大且近乎有序的情况下，比归并更快。

下面也将查部分的插入排序加入代码段

	// 将arr[l...mid]和arr[mid+1...r]两部分进行归并
template<typename  T>
void __merge(T arr[], int l, int mid, int r){

    T *aux = new T[r-l+1];

    for( int i = l ; i <= r; i ++ )
        aux[i-l] = arr[i];

    // 初始化，i指向左半部分的起始索引位置l；j指向右半部分起始索引位置mid+1
    int i = l, j = mid+1;
    for( int k = l ; k <= r; k ++ ){

        if( i > mid ){  // 如果左半部分元素已经全部处理完毕
            arr[k] = aux[j-l]; j ++;
        }
        else if( j > r ){  // 如果右半部分元素已经全部处理完毕
            arr[k] = aux[i-l]; i ++;
        }
        else if( aux[i-l] < aux[j-l] ) {  // 左半部分所指元素 < 右半部分所指元素
            arr[k] = aux[i-l]; i ++;
        }
        else{  // 左半部分所指元素 >= 右半部分所指元素
            arr[k] = aux[j-l]; j ++;
        }
    }

    delete[] aux;
}

// 使用优化的归并排序算法, 对arr[l...r]的范围进行排序
template<typename T>
void __mergeSort(T arr[], int l, int r){

    // 对于小规模数组, 使用插入排序
    if( r - l <= 15 ){
        insertionSort(arr, l, r);
        return;
    }

    int mid = (l+r)/2;
    __mergeSort(arr, l, mid);
    __mergeSort(arr, mid+1, r);

    // 对于arr[mid] <= arr[mid+1]的情况,不进行merge
    // 对于近乎有序的数组非常有效,但是对于一般情况,有一定的性能损失
    if( arr[mid] > arr[mid+1] )
        __merge(arr, l, mid, r);
}

template<typename T>
void mergeSort(T arr[], int n){

    __mergeSort( arr , 0 , n-1 );
}
// 对arr[l...r]范围的数组进行插入排序
template<typename T>
void insertionSort(T arr[], int l, int r){

    for( int i = l+1 ; i <= r ; i ++ ) {

        T e = arr[i];
        int j;
        for (j = i; j > l && arr[j-1] > e; j--)
            arr[j] = arr[j-1];
        arr[j] = e;
    }

    return;
}

3.额外空间的优化。

对于额外空间的优化其实很简单，只是将频繁的申请释放内存过程，直接在一开始阶段就申请好。

这样避免了频繁的申请、释放内存，浪费时间的同时，有可能使得空间申请失败。

于是我们就在一开始申请和原数组一样大的内存空间，每次merge 的时候只需要先cpoy一下。

这样空间复杂度虽然没有变化，但是时间性能还是有显著提高。


// 将arr[l...mid]和arr[mid+1...r]两部分进行归并
// 其中aux为完成merge过程所需要的辅助空间
template<typename  T>
void __merge2(T arr[], T aux[], int l, int mid, int r){

    // 由于aux的大小和arr一样, 所以我们也不需要处理aux索引的偏移量
    // 进一步节省了计算量:)
    for( int i = l ; i <= r; i ++ )
        aux[i] = arr[i];

    // 初始化，i指向左半部分的起始索引位置l；j指向右半部分起始索引位置mid+1
    int i = l, j = mid+1;
    for( int k = l ; k <= r; k ++ ){

        if( i > mid ){  // 如果左半部分元素已经全部处理完毕
            arr[k] = aux[j]; j ++;
        }
        else if( j > r ){  // 如果右半部分元素已经全部处理完毕
            arr[k] = aux[i]; i ++;
        }
        else if( aux[i] < aux[j] ) {  // 左半部分所指元素 < 右半部分所指元素
            arr[k] = aux[i]; i ++;
        }
        else{  // 左半部分所指元素 >= 右半部分所指元素
            arr[k] = aux[j]; j ++;
        }
    }

}

// 使用优化的归并排序算法, 对arr[l...r]的范围进行排序
// 其中aux为完成merge过程所需要的辅助空间
template<typename T>
void __mergeSort2(T arr[], T aux[], int l, int r){

    // 对于小规模数组, 使用插入排序
    if( r - l <= 15 ){
        insertionSort(arr, l, r);
        return;
    }

    int mid = (l+r)/2;
    __mergeSort2(arr, aux, l, mid);
    __mergeSort2(arr, aux, mid+1, r);

    // 对于arr[mid] <= arr[mid+1]的情况,不进行merge
    // 对于近乎有序的数组非常有效,但是对于一般情况,有一定的性能损失
    if( arr[mid] > arr[mid+1] )
        __merge2(arr, aux, l, mid, r);
}


template<typename T>
void mergeSort2(T arr[], int n){

    // 在 mergeSort2中, 我们一次性申请aux空间,
    // 并将这个辅助空间以参数形式传递给完成归并排序的各个子函数
    T *aux = new T[n];

    __mergeSort2( arr , aux, 0 , n-1 );

    delete[] aux;   // 使用C++, new出来的空间不要忘记释放掉:)
}

三、自下而上-迭代归并

自底向上的思路，稍显复杂。但是很有实际意义。
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

// 自底向上的归并排序中, merge函数并没有改变
// 将arr[l...mid]和arr[mid+1...r]两部分进行归并
template<typename  T>
void __mergeBU(T arr[], int l, int mid, int r){

    //* VS不支持动态长度数组, 即不能使用 T aux[r-l+1]的方式申请aux的空间
    //* 使用VS的同学, 请使用new的方式申请aux空间
    //* 使用new申请空间, 不要忘了在__merge函数的最后, delete掉申请的空间:)
    T aux[r-l+1];
    //T *aux = new T[r-l+1];

    for( int i = l ; i <= r; i ++ )
        aux[i-l] = arr[i];

    // 初始化，i指向左半部分的起始索引位置l；j指向右半部分起始索引位置mid+1
    int i = l, j = mid+1;
    for( int k = l ; k <= r; k ++ ){

        if( i > mid ){  // 如果左半部分元素已经全部处理完毕
            arr[k] = aux[j-l]; j ++;
        }
        else if( j > r ){  // 如果右半部分元素已经全部处理完毕
            arr[k] = aux[i-l]; i ++;
        }
        else if( aux[i-l] < aux[j-l] ) {  // 左半部分所指元素 < 右半部分所指元素
            arr[k] = aux[i-l]; i ++;
        }
        else{  // 左半部分所指元素 >= 右半部分所指元素
            arr[k] = aux[j-l]; j ++;
        }
    }

    //delete[] aux;
}

// 使用自底向上的归并排序算法
template <typename T>
void mergeSortBU(T arr[], int n){

    // Merge Sort Bottom Up 无优化版本
    for( int sz = 1; sz < n ; sz += sz )
        for( int i = 0 ; i < n - sz ; i += sz+sz )
   // 对 arr[i ： i+sz-1] 和 arr[i+sz ： min(i+sz+sz-1,n-1)] 进行归并
           if( arr[i+sz-1] > arr[i+sz] )
            	__mergeBU(arr, i, i+sz-1, min(i+sz+sz-1,n-1) );

}

1.caution：

for( int sz = 1; sz < n ; sz += sz )

  1. int sz = 1 ; sz += sz;代表的是，第一次是将两个大小为1的合并起来。然后每次区间翻倍。
  2. 即：第一次将两个1合并为大小为2的、第二次将大小为2的合并成大小为4的。1、2、4、8、16这样下去。

for( int i = 0 ; i < n - sz ; i += sz+sz )

  1. i < n - sz ；为的是合并arr[i…i+sz-1] 和 arr[i+sz…i+2*sz-1] 时，第二个区间还存在.
  2. i += sz+sz 为的是，每次跳过合并好的两个区间。

__mergeBU(arr, i, i+sz-1, min(i+sz+sz-1,n-1) );

  1. merge 中min(i+sz+sz-1,n-1) ，为了取其最小值，防止越界

参考

模板类、模板函数设计

bobo老师的github

怎么这么帅啊
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
STL源码分析《3》----辅助空间不足时，如何进行归并排序
L.J.SHOU的专栏
03-07 2319
归并排序最核心的算法就是 将两个已经排序的数组在 O(N)时间内合并成一个有序数组。 但是合并的过程中一般需要  m + n 的额外辅助空间。其中， m 、 n 是两个已经排序数组的长度。 现在假如，   1〉 辅助空间 bufSize   2〉 bufSize   3〉假如没有辅助内存呢？？ STL implace_merge 函数在其实现中分别考虑了上述三种情况，并且尽可能
排序算法 - 归并排序详解
张大安的博客
05-09 4523
基本介绍 归并排序（MERGE-SORT）是利用归并的思想实现的排序方法，该算法采用经典的分治（divide-and-conquer）策略（分治法将问题分(divide)成一些小的问题然后递归求解，而治(conquer)的阶段则将分的阶段得到的各答案"修补"在一起，即分而治之)。 基本思想 将序列中待排序数字分为若干组，最终每个数字分为一组。（默认长度为1的序列是有序的） 将若干个组两两合并，保证合并后的组是有序的。（俩个子序列头部进行比较大小） 重复第二步操作直到只剩下一组，排序完成。 归并排序思想示
掌握 STL 中的分区技术：std::partition 优化 C++ 代码性能
最新发布
Lion_Long的博客
04-30 1178
对集合进行分区（Partitioning ）就是重新排列它，使得满足给定谓词的元素移到最前面，而不满足该谓词的元素移到其后面。第一个不满足谓词的元素称为分区点。这也是满足谓词的子范围的结束点：分区是一种常见的数据操作，它将一个集合或范围中的元素按照某个条件重新排列，使得满足给定条件的元素都聚集在前面，而不满足条件的元素聚集在后面。这样做的目的是为了后续的其他操作提供便利，比如查找、删除等。分区的关键点在于确定一个"分区点"，它是第一个不满足给定条件的元素的位置。
图解归并排序，带你彻底了解清楚！
热门推荐
程序员的时光
07-29 1万+
写在前面： 大家好，我是时光。 今天给大家带来的是排序算法中的归并排序，这种排序需要拆分归并。 我采用图解方式讲解，争取写透彻。话不多说，开始！ 思维导图： 归并排序思维导图 1，归并排序的概念 1.1，算法介绍 和选择排序一样，归并排序的性能不受输入数据的影响，但表现比选择排序好的多，因为始终都是O(n log n）的时间复杂度。代价是需要额外的内存空间。归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。
【数据结构从菜鸟到大牛】10分钟搞懂归并排序 ~ ＜归并排序算法＞【图解算法】【归并排序非递归】
K_04_10的博客
07-03 606
什么是归并排序 归并排序的原理，画图演示归并排序过程 归并排序的非递归实现
说说算法工程师面试必考项：排序算法
yihuliunian的博客
06-30 200
转载自品略图书馆http://www.pinlue.com/article/2020/06/3014/4710901582333.html 排序是最基本的算法之一，常见的排序算法有插入排序、希尔排序、选择排序、冒泡排序、堆排序、归并排序及快速排序。每个排序算法的时间复杂度是不同的，但是最优的时间复杂度是O(NlogN)。有些排序算法是原址排序（即不需要额外空间），也有一些是非原址排序，这也是需要注意的特点。同样地，还要注意排序算法是否是稳定排序，这有时候很重要。这篇文章简单地介绍各个排序算法的思想..
归并排序算法
weixin_58463882的博客
08-21 418
所谓归并，就是将两个或两个以上的有序序列合并成一个新的有序序列的过程。 首先将输入数组进行一次拷贝； 然后每一次我们都比较拷贝数组最开始的那个元素。哪个元素小，我们就把它赋值回归并以后的那个数组（原始输入数组）中； 直到拷贝数组中所有的元素都遍历完成（都赋值回去）。 可以看到在数组的归并需要使用额外的空间。注意，使用额外的空间是合理有效的做法。使用额外空间用于辅助数组归并的好处是：如果一个元素在数组靠后的位置，它可以借助辅助数组一下子来到数组的前面，正好解决了插入排序的痛点，并且也使...
C++实现的归并排序算法详解
08-30
"C++实现的归并排序算法详解" 归并排序算法是建立在归并操作上的一种有效的排序算法，采用分治法（Divide and Conquer）来实现排序。该算法将已有序的子序列合并，得到完全有序的序列。其主要步骤包括：将待排序...
C++排序算法之归并排序源码
06-29
C++排序算法之归并排序源码
C++实现希尔、快速、堆排序、归并排序算法
01-21
本文将详细介绍C++中实现的希尔排序、快速排序、堆排序和归并排序这四种经典排序算法。 希尔排序，由Donald Shell于1959年提出，是一种改进的插入排序。它的基本思想是通过设置一个增量序列，将待排序的元素按照...
C++实现归并排序算法
12-20
归并排序的时间复杂度为O(n log n)，空间复杂度为O(n)，因为它需要额外的空间来存储合并过程中的临时序列。尽管如此，由于其稳定的排序特性（相同元素的相对顺序不会改变），在处理大规模数据或需要稳定性的场景下，...
排序算法-归并排序及改进 C++实现
zhapeng1的博客
06-06 846
归并排序是一个复杂度为O(nlogn)的算法，一般出现复杂度有logn的情况，都是采用了一种类似树形结构的方法。 原理 归并排序将数据如下图不断二分，如果分开的部分已经排好序，那么只需要将这两个部分合并即可。 但是如果分到最后一层，那么只有一个数据就是排好序的，将所有的数据网上归并即可。 分完层之后就是对数据进行归并处理，这个问题看起来很简单，但是细细想来还挺复杂的。因为只对原数组进行操作并不能达到目的，此时需要另外开辟一个空间进行辅助操作。这也就是说插入排序需要额外使用O(n)的空间复杂度。 开辟了额
【排序算法】C++归并排序原理及代码实现
weixin_43872912的博客
03-14 1458
归并排序是用分治思想所提出的一种排序方法，它的思想就是把一组数据先拆再合，合的时候从单个开始合的时候就进行排序。 如图所示，在合的时候相邻两个两两组合并排序。 算法步骤： 1、从单个元素开始申请一个两个子元素合并后大小的空间。 2、因为已知两个子数组是排序完全的，所以只要从左到右以次比较，谁小放前面即可。 3、排序完成后，开始迭代，直到整组数据排序完成。 #include<iostream> #include<new> void merge(int* a, int start,
算法之——归并排序和快速排序
IT荻的博客
02-08 4234
归并排序 归并排序（Merge sort）是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。 作为一种典型的分而治之思想的算法应用，归并排序的实现由两种方法： 自上而下的递归（所有递归的方法都可以用迭代重写，所以就有了第 2 种方法）； 自下而上的迭代； 和选择排序一样，归并排序的性能不受输入数据的影响，但表现比选择排序好的...
归并排序（C++迭代实现，解释菜鸟教程的代码）
qq_41150769的博客
09-10 433
#include <iostream> using namespace std; // 归并排序(迭代 模板函数) template<typename T> void merge_sort(T arr[], int len) { T* a = arr; T* b = new T[len]; // seg:步长 每次循环增加一倍 1 2 4 8 16，直到超过数组长度 for(int seg = 1; seg < len; seg += seg) {.
C++序列操作之std::partition
u014023993的专栏
08-14 1万+
C++序列操作之std::partitionstd::partition会将区间[first,last)中的元素重新排列，满足判断条件pred的元素会被放在区间的前段，不满足pred的元素会被放在区间的后段。该算法不能保证元素的初始相对位置，如果需要保证初始相对位置，应该使用stable_partition. partition源代码如下：template<class BidirectionalI
c++11：std::partition
李白
10-21 2361
头文件：<algorithm> (1) template<classBidirIt,classUnaryPredicate> BidirIt partition(BidirIt first, BidirIt last, UnaryPredicate p); (C++11 前) template<classForwardIt,classUnaryPredicate> Forwa...
C++11标准模板（STL）- 算法 - 划分操作（std::partition）
qq_40788199的博客
11-14 833
1) 重排序范围 [first, last) 中的元素，使得谓词 p 对其返回 true 的元素前于谓词 p 对其返回 false 的元素。不保持相对顺序。
C++详解：比较与非比较排序算法及直接插入排序示例
本文提供了C++实现的直接插入排序代码，并结合理论分析了其在不同情况下的时间复杂度和适用性，对于理解基础排序算法及其在实际编程中的应用非常有帮助，尤其是在面试时考察对基本数据结构和排序策略的理解。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值