算法基础1.1：排序（快排，归并）与二分（整数，浮点数）

sunluyang521

已于 2024-05-19 13:17:59 修改

阅读量826

点赞数 28

分类专栏：算法基础文章标签： c++ 算法

于 2024-02-12 18:09:13 首次发布

本文链接：https://blog.csdn.net/sunluyang521/article/details/136097046

版权

算法基础专栏收录该内容

13 篇文章 0 订阅

订阅专栏

排序主要是快速排序和归并排序，定义排序算法稳定不是指时间效率是稳定的，而是指两个原序列的值是相同的，在排完序以后位置不发生变化就为稳定的，可能发生变化则不稳定，快排不稳定，可想一个机制让快排的数都不同，可把a[i]定义为二元组（加上下标）双关键词排序，此时快排中数都不同，一定稳定，归并稳定。

快排和归并的时间复杂度都为n乘以以2为底n的对数,快排为平均时间复杂度，最快为n的平方但没达到，归并起初长度为n，排一次为两个二分之n，第三层为四个四分之n，直到n个长度为1的区间，n除log n次为1，共logn层，每层的复杂度为n，总共nlog n，快排每次划分期望为二分之n，因此高度期望也为log n，一共n层，也为nlogn。

二分主要为整数二分（易出错，发生死循环，边界问题）和浮点数二分

学习算法：1.学习主要思想

2.理解并且背过代码模板，模板题可以快速默写出来，重复三到五次（提高最快）

排序：快速排序

主要思想是基于分治，为了把一组无序的数有序排列，假设存放一组数的数组为q，最左和最右的数分别为l和r

1.确定分界点x：q[l], q[(l+r)/2], q[r] 或随机(不一定等于x)

2.调整区间（最重要，最难）：根据x的值把整个区间划分为两部分（长度不一定相等），使得左边第一个区间里的数都小于等于x，右边第二个区间里的数都大于等于x，

3.递归处理左右两段分别排好序，拼接在一起（左边最大值小于等于右边最小值）

对于第二步：

第一种方法（暴力，开辟空间，时间复杂度线性，On）

1.先开两个新数组a和b

2.扫描一下l到r，q[i]小于等于x，放到数组a中，q[i]大于等于x，放到数组b中

3. 先a后b放回q中

第二种方法（优美，不需开辟额外空间）

假设指向最左和最右的指针分别为i和j，都往中间走，如果i指向的数小于等于x，就往后走，直到i指向的数大于x，i就停下来，移动j，如果j指向的数大于等于x，就往前走，直到j指向的数小于x，此时交换i和j指向的数，swap(q[i],q[j])，i和j再继续往中间走，直到i和j相遇为止

注意到在任何时刻i左边的数都一定小于x，j右边的数都一定大于x，

比如 3 1 2 3 5，取x=3，3和5分别为q[i]和q[j]指向的数，i指向的3不满足小于3，i停下来，然后看j，j指向的5大于j，j向前走指向3，不满足大于3，因此i和j指向的数交换，交换后i和j往中间移动一位，i指向1满足小于3，往后移动一位，此时i和j同时指向2，2小于3，i向后移动一位指向第二个3，不满足小于3，i停下来，然后看j，2不满足大于3，停下来，此时i和j穿过了，不能交换这两个数，此时用j来分，3 1 2为左段小于等于3，3 5为右段大于等于3。

此时需要处理很多细节问题，比如下标和边界问题，建议背过模板。

模板题：给定你一个长度为 n 的整数数列。

请你使用快速排序对这个数列按照从小到大进行排序。

并将排好序的数列按顺序输出。

输入格式

输入共两行，第一行包含整数 n。

第二行包含 n个整数（所有整数均在 1∼109的9次方范围内），表示整个数列。

输出格式

输出共一行，包含 n个整数，表示排好序的数列。

数据范围

1≤n≤100000

输入样例：

5
3 1 2 4 5

输出样例：

1 2 3 4 5

#include<iostream>

using namespace std;

const int N=1e6+10;

int n;

int q[N];

void quick_sort(int q[],int l,int r)

{ if(l>=r) return; //判边界，如果只有一个或没有数就return,也可l==r，

int x=q[l] //确定分界点

int i=l-1，j=r+1；//两个指针，因为i和j每次交换时都要往中间移动一格，所以每次循环时先往中间移动一次，因此i和j开始时在l和r的左右两侧一格

while(i<j) //每次循环迭代

{

do i++; while(q[i]<x);

do j--;while(q[j]>x);

if(i<j) swap(q[i],q[j]); //如果没有swap这个函数，也可 int t=q[i];q[i]=q[j];q[j]=t;

}

quick_sort(q,l,j);

quick_sort(q,j+1,r); //对称，这一种取x时不能取右边界q[r],也可把所有j都换成i，+1换-1，如果写i，定分界点的x不能写成左边界l，否则会有边界问题无限递归，可写成r或 (l+r+1)/2

int main

{

scanf(“%d",&n);//在读入较多数据时，scanf会比较快。

for (int i =0;i<n;i++) scanf("%d”，&q[i]);

quick_sort(q,0,n-1);

for (int i =0;i<n;i++) prinf("%d”，q[i]);

return 0;

}

作者：yxc
链接：https://www.acwing.com/activity/content/code/content/39790/
来源：AcWing

例题：给定一个长度为 n的整数数列，以及一个整数 k，请用快速选择算法求出数列从小到大排序后的第 k 个数。

输入格式

第一行包含两个整数 n 和 k。

第二行包含 n个整数（所有整数均在 1∼1091∼109 范围内），表示整数数列。

输出格式

输出一个整数，表示数列的第 k小数。

数据范围

1≤n≤100000,
1≤k≤n

输入样例：

5 3
2 4 1 5 3

输出样例：

#include <iostream>

using namespace std;

const int N = 100010;

int q[N];

int quick_sort(int q[], int l, int r, int k)
{
if (l >= r) return q[l];

int i = l - 1, j = r + 1, x = q[l + 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]);
}

if (j - l + 1 >= k) return quick_sort(q, l, j, k);//j-l+1为左边全部的数，左边比k大就在左找
else return quick_sort(q, j + 1, r, k - (j - l + 1));
}

int main()
{
int n, k;
scanf("%d%d", &n, &k);

for (int i = 0; i < n; i ++ ) scanf("%d", &q[i]);

cout << quick_sort(q, 0, n - 1, k) << endl;//需传入k；

return 0;
}
作者：yxc
链接：https://www.acwing.com/activity/content/code/content/39790/
来源：AcWing

排序：归并排序

主要思想也是分治，分治方法不一样，以下标的中间点为分界点分为左left右right两段

1.确定分界点，mid=(l+r)/2

2.递归排序左边和右边，排成有序

3.（最难）归并，合二为一，把两个有序的数组合并为一个有序的数组，两个指针分别扫描原序列的左右两段，每个元素只会被比较和移动一次，因此时间复杂度是On的

双指针算法，假设已为两个有序序列，用两个指针分别指向开头两个数组的最小值，比较两个指针指向的数，较小的即为两个数组中最小的数，假设第一个数组第一个数较小，开一个新的数组存放这个数，第一个数组的指针向后一位，再比较两个指针指向的数，较小的数再放入新数组，以此类推，直到一指针到终点为止，然后停止循环，剩下一个数组中所有数补进新数组后

假设：1 3 5 7 9 2 4 5 8 10

先拿1移动到3，再拿2移动到4，拿3指5，拿4指5，当两个指针指向数相同时拿哪个都可以，一般拿第一个数组的，拿5指7，拿5指8，拿7指9，拿8指10，拿9放10。

模板题：给定你一个长度为 n 的整数数列。

请你使用归并排序对这个数列按照从小到大进行排序。

并将排好序的数列按顺序输出。

输入格式

输入共两行，第一行包含整数 n。

第二行包含 n个整数（所有整数均在 1∼10的9次方范围内），表示整个数列。

输出格式

输出共一行，包含 n个整数，表示排好序的数列。

数据范围

1≤n≤100000

输入样例：

5
3 1 2 4 5

输出样例：

1 2 3 4 5

#include <iostream>

using namespace std;

const int N = 1e5 + 10;

int a[N], tmp[N]; //tmp为辅助数组

void merge_sort(int q[], int l, int r) //要排序数组，左边界，右边界
{
if (l >= r) return; //只有一个或没有数返回

int mid = l + r >> 1; //确定中间分界点

merge_sort(q, l, mid), merge_sort(q, mid + 1, r); //递归排序左右

int k = 0, i = l, j = mid + 1; //k判断两个序列已经合并几个数了，i指向左边有序列起点，j指向右边有序列起点，
while (i <= mid && j <= r)
if (q[i] <= q[j]) tmp[k ++ ] = q[i ++ ];//谁小拿谁存到tmp中
else tmp[k ++ ] = q[j ++ ];
while (i <= mid) tmp[k ++ ] = q[i ++ ];//最后剩余部分拿取直接接后面
while (j <= r) tmp[k ++ ] = q[j ++ ];

for (i = l, j = 0; i <= r; i ++, j ++ ) q[i] = tmp[j];//i为原序列，j为临时序列，把结果拿回来
}

int main()
{
int n;
scanf("%d", &n);
for (int i = 0; i < n; i ++ ) scanf("%d", &a[i]);

merge_sort(a, 0, n - 1);

for (int i = 0; i < n; i ++ ) printf("%d ", a[i]);

return 0;
}

作者：yxc
链接：https://www.acwing.com/activity/content/code/content/39790/
来源：AcWing

例题：

给定一个长度为 n 的整数数列，请你计算数列中的逆序对的数量。

逆序对的定义如下：对于数列的第 i个和第 j个元素，如果满足 i<j且 a[i]>a[j]，则其为一个逆序对；否则不是。

输入格式

第一行包含整数 n，表示数列的长度。

第二行包含 n个整数，表示整个数列。

输出格式

输出一个整数，表示逆序对的个数。

数据范围

1≤n≤100000，
数列中的元素的取值范围 [1,10的9次方]。

输入样例：

6
2 3 4 5 6 1

输出样例：

#include <iostream>

using namespace std;

typedef long long LL; //把原序列倒回来，n一直到1，逆序对最多，共有n乘n-1/2，n最大为100000，会爆掉int，重定义long long int为LL

const int N = 1e5 + 10;

int a[N], tmp[N];

LL merge_sort(int q[], int l, int r)
{
if (l >= r) return 0;

int mid = l + r >> 1;

LL res = merge_sort(q, l, mid) + merge_sort(q, mid + 1, r);//逆序对共有三种情况：1.两左 l到mid 2.两右 mid+1到r
//3.一左一右假设左段的指针指向的值q[i]严格大于q[j],则q[i]后的数到mid一定大于q[j],因此此时逆序对数量为mid-i+1，因此需要在q[j]每次输出的时候加上mid-i+1.

int k = 0, i = l, j = mid + 1;
while (i <= mid && j <= r)
if (q[i] <= q[j]) tmp[k ++ ] = q[i ++ ];
else
{
res += mid - i + 1;
tmp[k ++ ] = q[j ++ ];
}
while (i <= mid) tmp[k ++ ] = q[i ++ ];
while (j <= r) tmp[k ++ ] = q[j ++ ];

for (i = l, j = 0; i <= r; i ++, j ++ ) q[i] = tmp[j];

return res;
}

int main()
{
int n;
scanf("%d", &n);
for (int i = 0; i < n; i ++ ) scanf("%d", &a[i]);

cout << merge_sort(a, 0, n - 1) << endl;

return 0;
}

二分：整数二分

二分的本质：在一个区间内部，二分一个答案或边界，每次选择答案所在的区间做下一步处理，每一次把整个区间长度缩小一半，每一次区间都把答案覆盖掉，每一次都能保证区间内一定有答案，当区间长度为1时，区间内的数一定是答案，二分时一定有解，如果无解与题目有关，不是单调性，如果有单调性则可以二分，可以二分不一定必须有单调性。本质是定义一种性质，一定有边界，一定可把边界二分出来，二分后可通过性质判断原问题无解，在一组数左半边不满足该种性质，在右半边满足，整个区间一分为二，二分可寻找性质的边界，可寻找左段右端点和右段左端点，为两个不同模板。写得乱很可能发生死循环

假设二分出左段右端点

1.找到中间值 mid=（l+r+1）/2

每次检查mid是否满足左段性质，如果ture则答案可能在mid到r中（包括mid），因为把【l，r】变成【mid，r】，所以更新方式为l=mid，如果false则答案可能在l到mid-1中（包括mid-1），因为把【l，r】变成【l，mid-1】，所以更新方式为r=mid-1，

假设二分出右段左端点

1.找到中间值 mid=（l+r）/2

每次检查mid是否满足右段性质，如果ture则答案可能在l到mid中（包括mid），因为把【l，r】变成【l，mid】，所以更新方式为r=mid，如果false则答案可能在mid+1到r中（包括mid+1），因为把【l，r】变成【mid+1，r】，所以更新方式为l=mid+1，

如何考虑是否用哪个模板，写完mid后写个check函数，想一下ture或false应该如何更新区间，看l或r=mid，如果更新方式为l=mid，r=mid-1，mid补上+1，否则不+1。

为什么要+1，mid为向下取整，假设l=r-1，mid=（r+l）/2，向下取整为l，如果ture，更新区间后l=mid=l，没变，会死循环，因此补+1，后mid为r，l，r循环后变r，r，停止。

模板题：给定一个按照升序排列的长度为 n 的整数数组，以及 q 个查询。

对于每个查询，返回一个元素 k的起始位置和终止位置（位置从 00 开始计数）。

如果数组中不存在该元素，则返回 -1 -1。

输入格式

第一行包含整数 n和 q，表示数组长度和询问个数。

第二行包含 n个整数（均在 1∼100001∼10000 范围内），表示完整数组。

接下来 q行，每行包含一个整数 k，表示一个询问元素。

输出格式

共 q行，每行包含两个整数，表示所求元素的起始位置和终止位置。

如果数组中不存在该元素，则返回 -1 -1

数据范围

1≤n≤100000
1≤q≤10000
1≤k≤10000

输入样例：

6 3
1 2 2 3 3 4
3
4
5

输出样例：

3 4
5 5
-1 -1

#include <iostream>

using namespace std;

const int N = 100010;

int n, m;
int q[N];

int main()
{
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i ++ ) scanf("%d", &q[i]);

while (m -- ) //循环m次
{
int x;
scanf("%d", &x);

int l = 0, r = n - 1; //第一步，二分一下起始坐标，
while (l < r)
{
int mid = l + r >> 1; //性质为x右面所有的数都大于x
if (q[mid] >= x) r = mid; //mid一定在右半边，答案是在左半边，更新成l到mid，第一个模板不补+1
else l = mid + 1;
}

if (q[l] != x) cout << "-1 -1" << endl; //不存在
else
{

cout << l << ' '; //输出l或r都可，因为结束后l与r相等

int l = 0, r = n - 1;
while (l < r)
{
int mid = l + r + 1 >> 1;
if (q[mid] <= x) l = mid; //性质定义成x左边的数都满足小于等于x，x为右边界，如果q 【mid】小于等于x，答案在右半边，mid也为答案，因此更新为【mid，r】，l=mid为第二个模板，补上+1。
else r = mid - 1;
}

cout << l << endl;
}
}

return 0;
}

作者：yxc
链接：https://www.acwing.com/activity/content/code/content/39790/
来源：AcWing