Acwing 排序

最新推荐文章于 2024-11-12 12:29:51 发布
最新推荐文章于 2024-11-12 12:29:51 发布
阅读量866 收藏 22
点赞数 17
分类专栏： 算法学习 文章标签： 算法 排序算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43060884/article/details/142846838
版权

1.快速排序

主要思想：基于分治思想。通过选择一个基准元素，将数组分为两部分，左边部分元素都小于等于基准，右边部分元素都大于等于基准。然后对这两部分分别递归地进行排序。

分区逻辑：双指针算法

  • 左指针i从左往右找到第一个大于等于基准的元素
  • 右指针从右往左找到第一个小于等于基准的元素
  • 交换两个元素，使得左侧部分小于等于基准，右侧部分大于等于基准

设l是待排序区间的左边界，r是右边界

  1. 确定分界点x（基准），可以取左边界的值q[l]，或右边界的值q[r]，或者中间位置的值q[(l + r)/2]
  2. 根据基准值，调整区间，使得左半边区间的值全都≤ x，右半边区间的值全都≥ x .
    采用双指针：左指针i从左边界l-1开始，往右扫描，右指针j从右边界r+1开始，往左扫描

为什么初始是l-1，r+1？
因为后续的不管执行交换与否，首先都先将i，j向内移动一位，所以一开始的两个指针都设置为超出边界一个位置

当满足条件q[i] < x时，i右移；直到不满足条件时，即q[i] >= x，i停下;

然后移动右指针j，j 当满足条件q[j] > x时，j左移；直到不满足条件时，即q[j] <= x，j停下；

交换q[i]和q[j] 将i右移一位，j左移一位，重复上面的操作，直到i和j相遇(最终i和j的位置为：i==j或i=j+1)。 此时左半区间的数都满足≤x，且左半区间的最后一个数的下标为j，右半区间的数都满足≥ x,且右半区间的第一个数的下标为i

  1. 递归处理左右两段，
    • 若用j来作为区间的分界，则[l, j] 都是≤x，[j + 1, r]都是≥x
    • 若用i来作为区间的分界，则[l, i - 1]都是≤x，[i, r]都是≥x

注意：
递归取[l, j]，[j + 1, r]区间时，基准值不能取右边界x=q[r]，不然会出现死循环问题，此时常取左边界x=q[l]或中间值 （eg:1,2 会出现死循环）
同理当递归取[l, i - 1]，[i,r]区间时，基准值不能取左边界x=q[l]，不然会出现死循环问题，此时常取左边界x=q[r] 或中间值 （eg:1,2 会出现死循环）
快排不稳定，平均时间复杂度nlogn。最坏情况（例如数组已经有序的情况下），时间复杂度为 𝑂 ( 𝑛 2 ) 𝑂(𝑛^2) O(n2)，但通过选择中间值作为基准，可以减少最坏情况的发生。

这里给出一个快排的板子：

// 快速排序函数，q[] 是待排序的数组，l 是左边界，r 是右边界
void quick_sort(int q[], int l, int r) {
    if (l >= r) return;  // 递归终止条件：当左边界大于或等于右边界时停止递归

    // 选择中间元素作为基准数，并初始化左右指针 i 和 j
    int x = q[(l + r) / 2], i = l - 1, j = r + 1;

    // 使用双指针法进行分区
    while (i < j) {
        // 从左边开始找到第一个大于等于基准数的元素
        do i++; while (q[i] < x);
        // 从右边开始找到第一个小于等于基准数的元素
        do j--; while (q[j] > x);
        // 如果 i 和 j 没有相遇，交换 q[i] 和 q[j]，确保左边都比基准数小，右边都比基准数大
        if (i < j) swap(q[i], q[j]);
    }
    
    // 递归处理左半部分
    quick_sort(q, l, j);
    // 递归处理右半部分
    quick_sort(q, j + 1, r);
}

Acwing 785.快速排序
在这里插入图片描述
具体实现代码（详解版）：

#include <iostream>
#include <algorithm>

using namespace std;

const int N = 1e6 + 10;  

int n;        
int q[N];     // 存储待排序的数组

// 快速排序函数，q[] 是待排序的数组，l 是左边界，r 是右边界
void quick_sort(int q[], int l, int r) {
    if (l >= r) return;  // 递归终止条件：当左边界大于或等于右边界时停止递归

    // 选择中间元素作为基准数，并初始化左右指针 i 和 j
    int x = q[(l + r) / 2], i = l - 1, j = r + 1;

    // 使用双指针法进行分区
    while (i < j) {
        // 从左边开始找到第一个大于等于基准数的元素
        do i++; while (q[i] < x);
        // 从右边开始找到第一个小于等于基准数的元素
        do j--; while (q[j] > x);
        // 如果 i 和 j 没有相遇，交换 q[i] 和 q[j]，确保左边都比基准数小，右边都比基准数大
        if (i < j) swap(q[i], q[j]);
    }
    
    // 递归处理左半部分
    quick_sort(q, l, j);
    // 递归处理右半部分
    quick_sort(q, j + 1, r);
}

int main() {
    cin >> n;  

   
    for (int i = 0; i < n; i++) cin >> q[i];

    
    quick_sort(q, 0, n - 1);

   
    for (int i = 0; i < n; i++) cout << q[i] << ' ';
    cout << endl;  

    return 0;  
}

Acwing 786.第k个数
在这里插入图片描述
实现思路：直接进行快排，然后注意第k个数的数组下标是k-1,即答案就是q[ k - 1].

#include <iostream>
#include <algorithm>

using namespace std;

const int N = 1e6 + 10;
int n , k;
int q[N];

//快速排序
void quick_sort(int q[],int l , int r){
    if(l >= r) return ;
    int x = q[(l + r) / 2], i = l - 1, j = r + 1;
    
    while(i < j){
        do i ++ ; while(q[i] < x);
        do j -- ; while(q[j] > x);
        if(i < j) swap(q[i] , q[j]);
    }
    quick_sort(q, l ,j);
    quick_sort(q, j + 1 ,r);
}

int main(){
    cin >> n >> k ;
    for(int i = 0 ; i < n ; i ++) cin >> q[i];
    
    quick_sort(q, 0 , n - 1);
    
    //第k个数
    cout << q[k - 1] << endl;
    
    return 0;
}

2.归并排序

主要思想：也是基于分治思想

  • 先确认分界点（下标）：一般取中间点（l + r) /2;
  • 对左右两个子数组分别进行递归排序
  • 将两个排好序的子数组合二为一

实现思路：设置左右指针和一个临时数组temp，左指针指向左区间的的第一个元素，右指针指向右区间的第一个元素，循环比较左右指针所指元素，两者较小的元素放入temp数组中，指针后移继续比较。直至某一指针到达末尾，将其中一个未放置完的区间的数再都放入temp数组。

归并排序的时间复杂度为 𝑂 ( 𝑛 l o g 𝑛 ) 𝑂(𝑛log𝑛) O(nlogn)，即使在最坏的情况下也是如此。它的性能较为稳定，适用于大规模数据的排序任务

归并排序的板子：

const int N = 1e6 + 10;  // 定义数组容量为 10^6 + 10

int n;
int q[N], temp[N];  // q[] 存储待排序的数组，temp[] 是归并时的临时数组

// 归并排序函数，q[] 是待排序的数组，l 是左边界，r 是右边界
void merge_sort(int q[], int l, int r) {
    if (l >= r) return;  // 递归终止条件：如果只有一个元素，直接返回

    int mid = (l + r) / 2;  // 取中间点，将数组分成两部分

    // 递归处理左半部分
    merge_sort(q, l, mid);
    // 递归处理右半部分
    merge_sort(q, mid + 1, r);

    // 合并两个有序的部分
    int i = l, j = mid + 1, k = 0;  // i 追踪左半部分，j 追踪右半部分，k 追踪临时数组
    while (i <= mid && j <= r) {
        if (q[i] <= q[j]) temp[k++] = q[i++];  // 左边小或相等时，将左边的元素放入临时数组
        else temp[k++] = q[j++];               // 否则将右边的元素放入临时数组
    }

    // 如果左半部分还有剩余元素，放入临时数组
    while (i <= mid) temp[k++] = q[i++];
    // 如果右半部分还有剩余元素，放入临时数组
    while (j <= r) temp[k++] = q[j++];

    // 将临时数组中的元素拷贝回原数组的对应位置
    for (i = l, k = 0; i <= r; i++, k++) q[i] = temp[k];
}

Acwing 787.归并排序
在这里插入图片描述
具体实现代码（详解版）：

#include <iostream>
using namespace std;

const int N = 1e6 + 10;  // 定义数组容量为 10^6 + 10

int n;
int q[N], temp[N];  // q[] 存储待排序的数组，temp[] 是归并时的临时数组

// 归并排序函数，q[] 是待排序的数组，l 是左边界，r 是右边界
void merge_sort(int q[], int l, int r) {
    if (l >= r) return;  // 递归终止条件：如果只有一个元素，直接返回

    int mid = (l + r) / 2;  // 取中间点，将数组分成两部分

    // 递归处理左半部分
    merge_sort(q, l, mid);
    // 递归处理右半部分
    merge_sort(q, mid + 1, r);

    // 合并两个有序的部分
    int i = l, j = mid + 1, k = 0;  // i 追踪左半部分，j 追踪右半部分，k 追踪临时数组
    while (i <= mid && j <= r) {
        if (q[i] <= q[j]) temp[k++] = q[i++];  // 左边小或相等时，将左边的元素放入临时数组
        else temp[k++] = q[j++];               // 否则将右边的元素放入临时数组
    }

    // 如果左半部分还有剩余元素，放入临时数组
    while (i <= mid) temp[k++] = q[i++];
    // 如果右半部分还有剩余元素，放入临时数组
    while (j <= r) temp[k++] = q[j++];

    // 将临时数组中的元素拷贝回原数组的对应位置
    for (i = l, k = 0; i <= r; i++, k++) q[i] = temp[k];
}

int main() {
    cin >> n;  // 输入数组长度

    // 读取 n 个元素存入数组 q 中
    for (int i = 0; i < n; i++) cin >> q[i];

    // 调用归并排序算法，排序整个数组
    merge_sort(q, 0, n - 1);

    // 输出排序后的数组
    for (int i = 0; i < n; i++) cout << q[i] << ' ';
    cout << endl;  // 换行

    return 0;  // 程序结束
}

Acwing.788求逆序对的数量
在这里插入图片描述
实现思路：

  • 根据归并排序的思想，将数组分为各自有序的左右两个区间[l,mid],[mid+1,r]，采用双指针开始分别指向两个区间的第一个元素，相互比较选出较小的那个元素，然后后移，不断循环，直到一个区间遍历完。
  • 在比较过程中，设i指向左区间，j指向右区间，由于两个区间各自有序，逆序对只会出现一种情况，即左区间存在大于右区间元素的元素。
  • 若a[i]>a[j]，则左区间中从i开始到mid的元素都大于a[j]，与a[j]组成逆序对，数量为mid-i+1

注意：对于给定n个数，最坏的情况为逆序，则逆序对数为n(n-1)/2个，题中数据个数范围为100000，则最大结果会超出int的存储范围(-231~231-1)，所以虽好使用long long来存储最终结果

具体实现代码（详解版）：

#include <iostream>
#include <algorithm>

using namespace std;

typedef long long LL;  
const int N = 1e6 + 10;  
int n;  
int q[N], temp[N];  // q[] 用于存储输入数组，temp[] 用于合并时的临时数组

// 归并排序函数，返回区间 [l, r] 的逆序对数量
LL merge_sort(int l, int r) {
    if (l >= r) return 0;  // 如果区间内只有一个元素，返回 0，表示没有逆序对
    
    int mid = (l + r) / 2;  // 找到中间位置
    
    // 递归处理左半部分和右半部分，并计算各自的逆序对数量
    LL res = merge_sort(l, mid) + merge_sort(mid + 1, r);
    
    // 合并两个有序区间，同时统计逆序对
    int i = l, j = mid + 1, k = 0;  // i 指向左区间，j 指向右区间，k 是 temp 的索引
    while (i <= mid && j <= r) {
        if (q[i] <= q[j]) {
            temp[k++] = q[i++];  // 如果左区间的元素小于等于右区间，取左区间的元素
        } else {
            temp[k++] = q[j++];  // 否则取右区间的元素
            res += mid - i + 1;  // 统计逆序对的数量，mid - i + 1 表示当前左区间剩余的元素个数
        }
    }
    
    // 如果左区间还有剩余元素，直接加入 temp[]
    while (i <= mid) temp[k++] = q[i++];
    // 如果右区间还有剩余元素，直接加入 temp[]
    while (j <= r) temp[k++] = q[j++];
    
    // 将 temp[] 中的元素复制回原数组 q[]
    for (int i = l, k = 0; i <= r; i++, k++) q[i] = temp[k];
    
    return res;  // 返回逆序对的数量
}

int main() {
   
    cin >> n;
   
    for (int i = 0; i < n; i++) cin >> q[i];
    
    // 输出逆序对的数量
    cout << merge_sort(0, n - 1) << endl;
    
    return 0;
}

以上就是两种经典常考的排序算法，快排的思想是选择基准点，然后进行分区；而归并排序是选择一个位置，将原序列划分为两个序列，再分别进行排序，最后合并为一个有序数组。可以看到各有优缺点，下面进行一个简答的总结：
在这里插入图片描述

Curry_Math
关注
专栏目录
AcWing 排序
aochongbi5356的博客
08-19 120
AcWing 排序 Description 给定 n 个变量，m 个不等式。 不等式之间具有传递性，即若 A>B 且 B>C ，则 A>C。 判断这 m 个不等式是否有矛盾。 若存在矛盾，则求出 t 的最小值，满足仅用前 t 个不等式就能确定不等式之间存在矛盾。 若无矛盾，则判断这 m 个不等式是否能确定每一对变量之间的关系。 若能，则求出 t 的最小值，满足仅用前 ...
acwing排序算法大全
MrsSnape的博客
11-24 348
快速排序
AcWing 排序 （插入排序， 快速排序)
2301_81144904的博客
11-15 57
Acwing 笔记排序
Acwing排序算法模板
qq_45417626的博客
10-26 694
【自用代码模板】；【代码】Acwing算法模板；Acwing算法基础课；排序；查找；
AcWing 排序不等式——913. 排队打水
a131529的博客
09-03 202
为了使得总的等待时间最小，我们肯定是要让花费时间小的排在前面，这样子对后面人造成的等待时间之和最小。
ACWing快速排序
acm2001的博客
07-18 520
快速排序 acwing–785 感谢作者YXC 一、算法思想 快速排序采用了分治思想 二、具体步骤 （一段数组的左右端点L,R) 1.取一个数组的q[l],q[r],q[l+r/2],任意取 2.分为两段，使得左面的<=x,右面的>=x 3.递归整理左右两段 第二步是重点 三、注意总结模板 四、题目 #include<iostream> #include<iomanip> #include<stdio.h> #include <stdlib.h>
AcWing--快速排序与归并排序
记得要努力变强
07-21 936
快速排序和归并排序
acwing归并排序
porting的博客
11-22 611
1，确定分界点mid 2，递归两段 3，合并 #include<iostream> using namespace std; const int N =1e6+10; int a[N],tmp[N];//a为原序列和结果序列，tmp为辅助序列 void merge_sort(int q[],int l,int r) { if(l>=r)return ; int mid=(l+r)/2;//分界 merge_sort(q,l,mid),merge_
AcWing——归并排序
weixin_73094970的博客
03-16 189
归并排序模板
【ACWing 算法基础】快速排序
m0_51139226的博客
07-27 402
快速排序的核心思想->分治既然是分治，遵循以下步骤分解成子问题；递归处理子问题；合并子问题；
Acwing快速排序和归并排序
weixin_43764776的博客
04-20 502
快速排序和归并排序 一.快速排序 思想步骤： （1）.以数组中某数为一个断点：q[l], q[r], q[l+r>>1] 或随机一个数 （2) .调整区间 （3）.递归，左右两区间再排序 1.。 2.调整区间：将数组中小于等于断点的数都挪至在左侧位置，将大于等于断点的数都挪至右侧位置。所以并不是以断点x为一个点，小于x的在左，大于x的在右，因为左边有等于x的，右边也有等于x的。 ...
[AcWing]Java——快速排序
m0_56632342的博客
01-25 311
Java快速排序模板例题
acwing 堆排序
07-16
ACWing是一家知名的在线编程学习平台，它提供多种计算机科学和技术课程，包括数据结构与算法的讲解。堆排序是一种基于比较的、非稳定的排序算法，其基本思想是利用堆这种特殊的树形数据结构来进行排序。堆可以分为...
16 合并区间
weixin_47521269的博客
11-12 737
【代码】16 合并区间。
数据库范式、MySQL 架构、算法与树的深入解析
lrh35的博客
11-11 1129
在数据库设计中，范式是一系列规则，用于确保数据的组织和存储具有良好的结构、完整性以及最小化的数据冗余。如果不遵循范式设计，数据可能会以平铺式罗列，仅使用冒号、分号等简单分隔。这种方式存在诸多弊端，例如在数据搜索时极为不便，数据修改也会变得十分棘手。由此，范式的概念应运而生。
点云配准之点到点，点到面，点到线ICP，NDT算法介绍
qq_54375651的博客
11-10 1521
点云配准在人工智能，自动驾驶，SLAM等任务中具有十分关键的作用，本文将介绍点云配准的点到点，点到线，点到面ICP和NDT算法
1-Equity-Transformer：求解NP-Hard Min-Max路由问题的顺序生成算法（AAAI-24)(完)（code）
最新发布
太极生两鱼
11-12 148
最小最大路由问题旨在通过智能体合作完成任务来最小化多个智能体中最长行程的长度。这些问题包括对现实世界有重大影响的应用场景，但已知属于NP-hard问题。现有方法在大规模问题上面临挑战，尤其是在需要协调大量智能体以覆盖数千个城市的情况下。本文提出了Equity-Transformer来解决大规模最小最大路由问题。首先，我们采用顺序规划方法来处理最小最大路由问题，使我们能够利用强大的序列生成器（例如，Transformer）。其次，我们提出了关键的归纳偏差，以确保智能体之间的公平工作量分配。
LeetCode题解：3.无重复字符的最长子串【python 题解超详细】
m0_74420622的博客
11-10 781
LeetCode题解：3.无重复字符的最长子串【python 题解超详细】，滑动窗口与暴力求解，知识拓展：什么是哈希函数
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值