排序算法总结——插入、归并、快排

最新推荐文章于 2025-02-22 23:23:44 发布
最新推荐文章于 2025-02-22 23:23:44 发布
阅读量148 收藏
点赞数
分类专栏： 算法与数据结构 文章标签： 算法 面试 排序 快速排序 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_34731182/article/details/113727477
版权

排序

文章目录

选择排序

void selectionSort(int arr[], int n){
 	int times=0;
    while(times<n){// 循环n次，每次找第n小的元素
		int minIdx=times;// 最小元素的索引
        for(int i=times;i<n;i++){
			if(arr[i]<arr[minIdx]){
                minIdx=i;
            }
        }
        swap(arr[minIdx],arr[times]);
        times++;
    }   
}

插入排序

  1. 对于近乎有序的数组，排序效率很高，时间复杂度接近O(n)
// 基础版
void insertionSort(int arr[], int n) {
    for(int i=0;i<n;i++){
		for(int j=i;j>0;j--){
            if(arr[j] < arr[j-1])
                swap(arr[j],arr[j-1]);
            else
                break;
        }
    }
}

// 优化版
// 减少不断交换中的重复赋值
void insertionSort(int arr[], int n) {
    for(int i=0;i<n;i++){
        int temp=arr[i];// 记录待排元素
        int j;// 记录待排元素应在的位置
		for(j=i;j>0;j--){
            if(temp < arr[j-1])
                arr[j]=arr[j-1];
            else
                break;
        }
        arr[j]=temp;
    }
}

归并排序

  1. O(nlogn)：将全部元素分为logn层，每层的时间复杂度为O(n)
  2. 缺点是多使用O(n)个存储空间
  3. 自顶向下的归并排序
// 递归实现归并排序
void mergeSort(int arr[], int n){
    __mergeSort(int arr[], 0, n-1);
}

// 自顶向下
// 基础版
void __mergeSort(int 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);
}

// 优化版
void __mergeSort(int arr[], int l, int r){
    // 优化1：对于小规模数组, 使用插入排序
    if(r-l<=15){
        insertionSort(arr, l,r);
        return;
    }
        
    int mid=(l+r)/2;
    __mergeSort(arr, l, mid);
    __mergeSort(arr, mid+1, r);
    // 优化2：只有arr[mid]>arr[mid+1]，才归并
    // 对于近乎有序的数组非常有效
    if(arr[mid]>arr[mid+1])
    	__merge(arr, l, mid, r);
}

// 将arr[l, mid]和arr[mid+1, r]两部分归并
void __merge(int arr[], int l, int mid, int r){
	int *temp=new int[r-l+1];
    
    for(int i=l;i<=r;i++)
        temp[i-l]=arr[i];
	
    int i=l, j=mid+1;
    for(int k=l;k<=r;k++){
        if(i>mid){
            arr[k]=temp[j-l];
            j++;
        }
        else if(j>r){
			arr[k]=temp[i-l];
            i++;
        }
        else if(temp[i-l]<temp[j-l]){
			arr[k]=temp[i-l];
            i++;
        }
        else{
             arr[k]=temp[j-l];
            j++;
        }
    }
    
    delete[] temp;
}
  1. 自底向上的归并排序：可以通过索引直接获取元素，适合于对链表排序。同时也是一种非递归实现的归并排序
// 自底向上实现归并排序
void mergeSortBU(int arr[], int n){
	// 第一轮循环：每次merge的元素个数（半区间）
    for(int sz=1;sz <= n;sz+=sz){
        // 第二轮循环：每次merge时起始的元素位置
		for(int l=0;l+sz < n;l+=sz+sz){// 注意越界问题
            // 对arr[l, l+sz-1]和arr[l+sz, l+sz+sz-1]两部分归并
			__merge(arr, l, l+sz-1, min(l+sz+sz-1, n));
        }
    }    
}

快速排序

  1. 基础版

  1. 缺点：对于近乎有序的数组，时间复杂度会退化为O(n^2)，因为每次选最左边的元素作为标定点，导致分成的partition两部分数组长度差异较大，以此类推时间消耗巨大。

  2. 解决办法：随机选择数组中的元素作为标定点

void quickSort(T arr[], int n){
    srand(time(NULL));// 初始化随机种子
    __quickSort(arr, 0, n-1);
}

// 对arr[l,r]部分进行快速排序
void __quickSort(T arr, int l, int r){}
    // 小规模数组用插入排序
    if(r-l<=15){
        insertionSort(arr, l, r);
        return;
    }
    int mid=_partition(arr, l, r);
    __quickSort(arr, l, mid-1);
    __quickSort(arr, mid+1, r);
}

// 返回j，使得arr[l,j-1]<arr[j]; arr[j+1,r]>arr[j]
// 基础版
int _partition(T arr[], int l, int r) {
    // 随机选择标定点：对于近乎有序的数组排序速度有较大提升
    swap(arr[l], arr[rand()%(r-l+1)+l])
    T target=arr[l];
    // arr[l+1,j]<target; arr[j+1,i)>target
    int j=l;
    for(int i=l+1; i<=r; i++){
		if(arr[i]<target)
            swap(arr[i], arr[++j]);
    }
    swap(arr[l], arr[j]);
   	return j;
}

  1. 若数组中有大量重复元素，时间复杂度仍然会退化为O(n^2)，因为大于标定点或小于标定点两部分中，有一部分会包含有大量重复元素，导致数组长度较长。

  2. 双路快排

int _parttion(T arr[], int l, int r){
	// 随机选择标定点：对于近乎有序的数组排序速度有较大提升
    swap(arr[l], arr[rand()%(r-l+1)+l]);
    T target=arr[l];
    // arr[l+1,i)<=target; arr(j,r]>=target
    int i=l+1, j=r;
	while(true){
		while(i<=r && arr[i] < target) i++;
        while(j>=l+1 && arr[j] > target) j--;
        
        if(i>j) break;
       	swap(arr[i], arr[j]);
        i++;
        j--;
    }
    // i在第一个大于等于taget的位置，j在最后一个小于等于target的位置
    swap(arr[l], arr[j]);
    return j;
}
  1. 三路快排
void __quickSort3Ways(T arr[], int l, int r){
	if(r-l+1)<=15{
        insertionSort(arr, l, r);
        return;
    }
    
    // partition
    swap(arr[l], arr[rand()%(r-l+1)+l]);
    T target=arr[l];
    int lt=l;// arr[l, lt] < target
    int gt=r+1;// arr[gt, r] > target
    int i=l+1;// arr[lt+1, i) == target
    while(i < gt){
        if(arr[i]==target)
            i++;
        else if(arr[i]<target)
            swap(arr[i++], arr[++lt]);
        else// arr[i]>target
            swap(arr[i], arr[--gt]);
    }
	swap(arr[l], arr[lt]);

    __quickSort3Ways(arr, l, lt-1);// 注意这里是-1
    __quickSort3Ways(arr, gt, r);
}
  1. 非递归实现的快速排序
void __quickSort(T arr[], int l, int r){
	stack<int> s;
    s.push(l);
    s.push(r);
    while(!s.empty()){
        int r=s.top();
        s.pop();
        int l=s.top();
        s.pop();
        
        // 小数组用插入排序
        if ((r - l + 1) < 15) {
            insertionSort(arr, l, r);
            continue;
        }
        
        int mid=_partion(arr, l, r);
        
        if(mid-1 > l){// 左子序列
            s.push(l);
            s.push(mid-1);
        }
        if(mid+1 < r){// 右子序列
            s.push(mid+1);
            s.push(r);
        } 
    }
}

排序算法衍生出的问题

  1. 求一个数组中逆序对的数量。数组中逆序对的数量可以衡量数组的有序程度。
// 暴力解法
int inversionCount(int arr[], int n){
    int num=0;
    for(int i=0; i<n-1; i++){
        for(int j=i+1;j<n; j++){
            if(arr[i] > arr[j])
                num++;
        }
    }
    return num;
}

// 归并排序法
long long __merge3(int arr[], int l, int mid, int r) {
    int* aux = new int[r - l + 1];

    long long count = 0;
    int i = l, j = mid + 1;
    for (int k = l; k <= r; k++) {
        if (i > mid) {
            aux[k-l] = arr[j];
            j++;
            continue;
        }
        else if (j > r) {
            aux[k-l] = arr[i];
            i++;
            continue;
        }
        if(arr[i] > arr[j]){
            count += (long long)(mid - i + 1);
            aux[k-l] = arr[j];
            j++;
        }
        else {
            aux[k-l] = arr[i];
            i++;
        }
    }
    for (int i = 0; i < (r - l + 1); i++)
        arr[l + i] = aux[i];

    delete[] aux;
    return count;
}

long long __inversionCount3(int arr[], int l, int r) {
    long long count = 0;
    for (int sz = 1; sz <= (r - 1 + 1); sz += sz)
        for (int i = l; i + sz - 1 < r; i += sz + sz) {
            count += __merge3(arr, i, i + sz - 1, min(i + sz + sz - 1, r));
        }
    return count;
}

// 对于一个大小为N的数组, 其最大的逆序数对个数为 N*(N-1)/2, 非常容易产生整型溢出
long long inversionCount3(int arr[], int n) {
    return __inversionCount3(arr, 0, n - 1);
}
  1. 求一个数组中第n大的元素
int __partition(int arr[], int l, int r) {
    swap(arr[l], arr[rand()%(r-l+1)+l]);
    int target = arr[l];

    int j = l;// arr[l+1, j]<=target
    int i = j + 1;// arr[j+1, i)>target
    for (; i <= r; i++) {
        if (arr[i] > target)
            continue;
        else
            swap(arr[i], arr[++j]);
    }
    swap(arr[l], arr[j]);
    return j;
}

int __selectKth(int arr[], int l, int r, int k) {

    int mid = __partition(arr, l, r);
    if (mid < k)
        __selectKth(arr, mid + 1, r, k);
    else if (mid > k)
        __selectKth(arr, l, mid - 1, k);
    else
        return arr[mid];
}

int selectKth(int arr[], int n, int k) {
    srand(time(NULL));
    return __selectKth(arr, 0, n - 1, k);
}

排序算法总结

  • 快速排序的额外空间为O(logN)：需要logN层的递归，这就需要logN个栈空间来保存每一层递归的临时变量以供递归返回时继续使用。
  • 稳定排序：对于相等的元素，排序后，原来靠前的元素依然靠前。即像等元素的相对位置没有改变。
  • 稳定排序与具体实现有关，可通过自定义比较函数，让排序算法不存在稳定性问题。
插入排序优化——超越归并排序的超级算法
小天狼星_布莱克 的博客
08-19 463
史上最快插入排序优化，解决 在有序数列中 边排序边操作 的问题！！
七大排序算法（Java实现）——冒泡、快排、插入、希尔、选择、堆排、归并
weixin_46356448的博客
04-24 784
*** 交换排序：稳定，O(n^2)* 1. 冒泡排序：* 相邻两个元素两两比较，若逆序则交换* 每一轮会确定一个最大值到它最后的位置上,只需n-1轮排序* 优化：如果某一轮排序从头至尾没有发生交换，说明已经有序，结束* @param array 待排序列*/i < n - 1;i++) { // n-1轮排序j++) { // 每轮会确定一个最值if(array[j] > array[j + 1]) { // 逆序则交换// 本轮发生了交换。
排序算法详解——选择、插入、归并和快排
qq_40438165的博客
08-27 1399
一、选择排序 特点：每次从待排序序列中选取最小值最为当前元素值 流程：已排好序的数组为A[0,i-1]，将未排序序列A[i,n)中最小值赋给A[i]。 const int maxn = 10000; int A[maxn]; void selectSort(int A[], int n) { for (int i = 0; i < n; ++i) { for (int j = i; ...
插入排序、归并排序和快速排序算法，编写完整程序实现三种排序算法
TS1m1m的博客
05-31 3879
实验内容 （1）针对插入排序、归并排序和快速排序算法，编写完整程序实现三种排序算法。 （2）采用随机生成测试用例的方法生成三组算法测试数据集。三组测试数据集的规模分别是：20000个数据、50000个数据、200000个数据。 （3）采用具有计时功能的函数，记录三种排序算法在三个数据集中进行排序所使用的时间，横向比较三种排序算法的性能。 （4）结合三种算法的逻辑过程、实践过程和实验结果，对三种算法...
排序算法——归并、快排
u014792301的博客
04-20 827
归并、快排归并排序快速排序 归并排序 归并排序的思想是分治法，如果想要将一个数组排序，那么将这个数组分为左区间和右区间，左区间一定是小于右区间的，再将左区间继续划分，右区间也继续划分。。。 最后将排好序的数组全都归并起来，这样听起来像是从上向下划分，其实归并排序主要是是从下向上，合并的过程。 先将单个元素的数组归并为两个元素的有序数组 再将包含两个元素的有序数组归并为四个元素的有序数组 … 最后...
【算法系列 | 4】深入解析排序算法之——归并排序
热门推荐
颜淡慕潇
06-10 2万+
排序算法是很常见的一类问题，主要是将一组数据按照某种规则进行排序。以下是一些常见的排序算法：冒泡排序（Bubble Sort）插入排序（Insertion Sort）选择排序（Selection Sort）归并排序（Merge Sort）快速排序（Quick Sort）堆排序（Heap Sort）归并排序（Merge Sort）是一种基于分治思想的排序算法，它将待排序的数组分成两部分，分别对这两部分递归地进行排序，最后将两个有序子数组合并成一个有序数组。
排序算法之——归并排序和快速排序
seniusen的博客
12-03 397
冒泡排序、插入排序、选择排序这三种算法的时间复杂度都为 O(n2)O(n^2)O(n2)，只适合小规模的数据。今天，我们来认识两种时间复杂度为 O(nlogn)O(nlogn)O(nlogn) 的排序算法——归并排序（Merge Sort）和快速排序（Quick Sort），他们都用到了分治思想，非常巧妙。 1. 归并排序（Merge Sort）？ 1.1. 归并排序算法实现 归并排序的核心...
【排序算法】六大比较类排序算法——插入排序、选择排序、冒泡排序、希尔排序、快速排序、归并排序【详解】
最新发布
2401_87820834的博客
02-22 2219
排序：所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减地排列起来地操作。稳定性：假定在待排序地记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，r[i] = r[j]，且 r[i] 在 r[j] 之前，而在排序后的序列中。r[i] 仍在 r[j] 之前。则称这种排序算法是稳定的。否则称为不稳定的。内部排序：数据元素全部放在内存中的排序。（我们下面讲的排序都是属于内部排序）外部排序。
万字总结——常见的八大排序算法（插入排序、希尔排序、选择排序、堆排序、冒泡排序、快速排序、归并排序、计数排序）
m0_73900674的博客
09-26 2735
二万字排序总结超详解（图示 + 动图）
算法设计与分析 ——插入排序算法与归并排序算法比较
shinian_acmer的博客鸭
11-07 3821
插入排序算法与归并排序算法比较 实验目的 通过插入排序算法与归并排序算法效率对比体会算法在求解问题中的重要性。 实验内容 分别编写函数实现插入排序算法和归并排序算法； 利用随机函数产生大量数据存入数组作为待排序列； 分别测试待排序列数据量为1000、1万、10万、100万、1000万的情况下两种算法各自的运行时间，通过对比分析...
【数据结构】排序算法（快速排序、归并排序、排序算法总结）
Become Mad的博客
07-30 1476
这一章节我们继续讲解排序的剩下部分，也是两个比较复杂的排序—快速排序和归并排序，希望大家认真学习，理解透彻~
图论基础——邻接表、邻接矩阵和图的遍历
qq_34731182的博客
04-06 3479
图论基础 文章目录图论基础概述图的表示邻接矩阵邻接矩阵表示无向图邻接矩阵表示有向图邻接矩阵代码邻接表邻接表表示无向图邻接表表示有向图邻接表代码两种表示的适用情况两种表示的优缺点邻边遍历图的遍历深度优先遍历广度优先遍历 概述 基础构成：图由节点和边构成 分类： 根据边的有向性分为无向图和有向图 根据边的权重可分为无权图和有权图 自环边：从自身节点出发指向自身的边 平行边：两个节点之间存在多条边 简单图：图中没有自环边和平行边 图的表示 邻接矩阵 邻接矩阵表示无向图
有权图——最小生成树、最短路径
qq_34731182的博客
04-06 885
有权图 文章目录有权图有权图的表示最小生成树Minimum Span Tree生成树切分定理Cut PropertyLazy PrimPrimKruskal最短路径松弛操作RelaxationDijkstra算法Bellman-Ford算法最短路径算法总结 有权图的表示 邻接矩阵表示有权图： 邻接表表示有权图： 边的表示： // 边 template<typename Weight> class Edge{ private: int a,b; //
算法经典面试题（7）——动态规划
qq_34731182的博客
02-04 527
*题目编号为Leetcode中对应的题号。 某位大佬的Leetcode题解参考链接 动态规划 斐波那契数列 F(0)=1, F(1)=1, F(n)=F(n-1)+F(n-2) // 基础版递归实现 int calcFib(int n){ assert(n>=0); if(n==0) return 1; if(n==1) return 1; return calcFib(n-1)+calcFib(n-2); }
堆、索引堆与堆排序
qq_34731182的博客
03-03 449
堆 文章目录堆优先队列基本实现Shift Up（向堆中插入一个元素）Shift Down（从堆中取出一个元素）Heapify堆排序索引堆堆相关的其他问题 优先队列 普通队列：先进先出；后进后出 优先队列：出队顺序和入队顺序无关，与优先级有关 适用于动态数据维护的情况 N个元素中选前M个，使用普通排序算法的时间复杂度为O(NlogN)，而使用堆排序的时间复杂度为O(NlogM) 基本实现 经典实现：二叉堆（Binary Heap） 二叉堆的特点： 任何一个节点都小于等
算法经典面试题（8）——贪心算法
qq_34731182的博客
02-05 438
*题目编号为Leetcode中对应的题号。 某位大佬的Leetcode题解参考链接 贪心算法 贪心算法的难点在于判断一个问题是否能用贪心算法解决。 贪心算法离不开排序。 (455 分发饼干) 假设你是一位很棒的家长，想要给你的孩子们一些小饼干。但是，每个孩子最多只能给一块饼干。对每个孩子 i ，都有一个胃口值 gi ，这是能让孩子们满足胃口的饼干的最小尺寸；并且每块饼干 j ，都有一个尺寸 sj 。如果 sj >= gi ，我们可以将这个饼干 j 分配给孩子 i ，这个孩子会得到满足。你的目标
算法经典面试题（6）——回溯法
qq_34731182的博客
02-04 319
*题目编号为Leetcode中对应的题号。 某位大佬的Leetcode题解参考链接 回溯法 (17 电话号码的字母组合) 给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。 示例: 输入："23" 输出：["ad", "ae", "af", "bd", "be", "bf", "cd", "ce", "cf"]. 说明: 尽管上面的答案是按字典序排列的，但是你可以任意选择答案输出的顺序。 class So
算法经典面试题（3）——链表
qq_34731182的博客
02-04 289
Leetcode题解参考链接 链表 给一个节点需要注意： 如果是头节点、尾节点或者空节点等特殊情况该如何处理 (206反转链表) 反转一个单链表。 示例: 输入: 1->2->3->4->5->NULL 输出: 5->4->3->2->1->NULL /** * Definition for singly-linked list. * struct ListNode { * int val;
算法经典面试题（4）——栈和队列
qq_34731182的博客
02-04 252
某位大佬的Leetcode题解参考链接 栈 (20有效的括号) 给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串，判断字符串是否有效。 有效字符串需满足： 左括号必须用相同类型的右括号闭合。 左括号必须以正确的顺序闭合。 注意空字符串可被认为是有效字符串。 示例 : 输入: "()[]{}" 输出: true 示例 : 输入: "([)]" 输出: false bool isValid(string s) { stack<char> reco
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值