第一章基础算法（一）

最新推荐文章于 2023-02-27 16:51:28 发布

二叉树下乘凉

最新推荐文章于 2023-02-27 16:51:28 发布

阅读量147

点赞数 1

分类专栏：数据结构与算法文章标签：算法排序算法数据结构 c++

本文链接：https://blog.csdn.net/m0_62076827/article/details/128309007

版权

数据结构与算法专栏收录该内容

5 篇文章 0 订阅

订阅专栏

第一章基础算法（一）

文章目录

第一章基础算法（一）

排序

快速排序

（1）主要思想：分治

（2）步骤：

确定分界点x：q[l]、q[(l + r) / 2]、q[r]、或随机；

调整区间：使得第一个区间内的值都 <= x，第二个区间内的值都 >= x；

递归处理左右两段：将左边和右边都排好序；

（3）调整区间的方法

解法一：暴力解法（空间复杂度高）——开辟两个数组a[],b[],扫描两次，a[]放置小于或等于基准数的数，b[]放置大于基准数的数，然后将a,b数组合并到q[]；

解法二：

建立两个指针 i，j；
指针 i 从左往右遍历，直到遇到大于 x 的元素，则停下；
指针 j 从右往左遍历，直到遇到小于 x 的元素，则停下；
指针 i，j 交换元素值，并继续重复上述步骤，直到两指针相遇，即 i == j；

例题：

785. 快速排序 - AcWing题库

给定你一个长度为 n 的整数数列。

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

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

输入格式

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

第二行包含 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 = 1e6 + 10;
int n;
int q[N];

void quick_sort(int q[], int l, int r)
{
	if (l >= r)return;//判边界
	int x = q[l+r>>1],  i = l - 1, j = r + 1;//确定分界点x，及确定指针i，j
	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()
{
	scanf("%d", &n);  
	for (int i = 0; i < n; i++)scanf("%d", &q[i]);
	quick_sort(q, 0, n - 1);
	for (int i = 0; i < n; i++)printf("%d ", q[i]);
	return 0;
}

注：很多情况下，在C++中 scanf 输入速度大于 cin ；

//***快排模板
void quick_sort(int q[], int l, int  r)
{
	if (l >= r)return;//判边界
	int x = q[l+r>>1],  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);
}
//（平均）时间复杂度：T(N)=O(NlogN);

/*注意：
当quick_sort(q, l, i-1);quick_sort(q, i, r);时，若分界点x=q[l]时，存在边界问题，取不到l；
同理：当quick_sort(q, l, j);quick_sort(q, j+1, r);时，若分界点x=q[r]时，存在边界问题，取不到r；*/
//当x=q[(l+r+1)/2]时无需考虑边界

归并排序

（1）主要思想：分治；

（2）步骤：

确定分界点: mid = (l + r) / 2;
递归排序（左left，右right）

归并排序（合二为一）

时间复杂度：O(N)

左右递归排好序后，将两个指针指向两序列的最左边，即两序列的最小值min；

两指针所指的元素值相比较，不妨设第一个指针指向的值更小，因此第一个指针所指的元素值进入结果数组res[]，并且第一个指针向后遍历一位；

依次类推，遍历序列，直到其中有一个指针遍历到序列末尾，若此时另一个序列还未遍历完，则将未遍历完的部分直接补到结果数组res[]中；

例题：

787. 归并排序 - AcWing题库

给定你一个长度为 n 的整数数列。

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

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

输入格式

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

第二行包含 nn 个整数（所有整数均在 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 = 1000010;
int n;
int q[N],tmp[N];
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;
	while (i <= mid && j <= r)
		if (q[i] <= q[j])tmp[k++] = q[i++];//谁小，谁先进入最终答案数组
		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];//补入结果数组
}
int main()
{
	scanf("%d", &n);
	for (int i = 0; i < n; i++)scanf("%d", &q[i]);
	merge_sort(q, 0, n - 1);
	for (int i = 0; i < n; i++)printf("%d ", q[i]);
	return 0;
}

//归并排序模板
void merge_sort(int q[], int l, int r)
{
	if (l >= r)return;
	int mid = 1 + r >> 1;//取中值
	merge_sort(q, l, mid), merge_sort(q, mid + 1, r);
	int k = 0, i = l, j = mid + 1;
	while (i <= mid && j <= r)
		if (q[i] <= q[j])tmp[k++] = q[i++];
		else tmp[k++] = q[j++];
	while (i <= mid)tmp[k++] = q[i++];
	while (j <= r)tmp[k++] = q[j++];
	for (i = 1, j = 0; i <= r; i++, j++)q[i] = tmp[j];
}

（3）时间复杂度：T(N) = O(nlogn)

归并排序不断递归分层，最终会分为n层，n除logn次可以除成1，因此有logn层，而每层计算量都是O(n)，所以总共计算量就是 nlogn；

快排与归并同理，其期望是logn的，而每层是O(n)，所以总共计算量也是nlogn；

注：

判断排序算法是否稳定：看其位置是否改变 eg :归并排序—稳定；快速排序—不稳定（若将快排变成双关键字(双下标)排序，则会变稳定）；

例子：如果序列中两个数相等，如果排序过后两数位置不发生变化，则代表该排序算法稳定；如果排序过后两数位置可能发生变化，则代表该排序算法不稳定；

二分法

整数二分

（1）本质：边界

注：有单调性一定可二分，无单调性也有可能二分，因此单调性不是二分的本质。

（2）前提：

已经排好序的线性表。

（3）步骤：

找中间值 mid = (l + r) / 2,并判断是否符合性质。

（3）主要思想：

存在某种性质，假设左边区间不符合性质，右边区间符合性质，二分的本质就是要找出两个区间的边界点；

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1dKJamsz-1670941441267)(https://lhk123.oss-cn-hangzhou.aliyuncs.com/image-20221213202723561.png)]

设左边红色区间( <= x)符合性质，mid = (l + r + 1) / 2，如果 check(mid) == true，即 mid 符合性质，在左区间内，则所求红色区间边界点( <= x 的最大值)在[mid , r]区间内，更新方式就是令 l = mid；

如果 check(mid) == false，即 mid 不符合性质，在右区间内，则所求边界点在[l,mid-1]区间内，更新方式就是令 r = mid - 1；

注：该模板中 mid = (l + r + 1) / 2，原因：若 mid = (l + r)/2，当 l=r-1 时，则 mid = l,之后更新的话 l = l，则会陷入死循环，报错；若 mid = (l + r + 1) / 2,则 mid = r，之后更新, l = r, 变为[l , r],最后变为[r ,r]，结束。

设右边绿色区间( >= x)符合性质，mid = (l+r)/2，如果check(mid) == true，即mid符合性质，在右区间内，则所求绿色区间边界点( >=x 的最小值)在[l,mid]区间内，更新方式就是令r=mid；

如果check(mid) == false，即mid不符合性质，在左区间内，则所求边界点在[mid+1,r]区间内，更新方式就是令l=mid+1；

例题：

789. 数的范围 - AcWing题库

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

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

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

输入格式

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

第二行包含 n 个整数（均在 1∼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--)
	{
		int x;
		scanf("%d", &x);
		int l = 0, r = n - 1;
		while (l < r)
		{
			int mid = l + r >> 1;
			if (q[mid] >= x)r = mid;
			else l = mid + 1;
		}
		if (q[l] != x)cout << "-1 -1" << endl;
		else
		{
			cout << l << ' ';
			int l = 0, r = n - 1;
			while (l < r)
			{
					int mid = l + r + 1 >> 1;
					if (q[mid] <= x)l = mid;
					else r = mid - 1;
			}
            cout << l << endl;//while之后l=r
		}
	}
	return 0;
}

//整数二分模板
//区间[l,r]被划分成[l,mid]和[mid+1,r]时使用
//（右边）绿色为true，（左边）红色为false
//求右区间的第一个点，即上述例题中符合大于等于x的第一个数字的位置——3
int bseaarch 1(int l, int r)
{
	while (l < r)
	{
		int mid = l + r >> 1;//核心,因为更新mid时r=mid;l=mid+1;
		if (check(mid))r = mid;//check()判断mid是否满足性质
		else l = mid + 1;
	}
	return l;
}
//区间[l,r]被划分成[l,mid-1]和[mid,r]时使用
//（左边）红色为true，（右边）绿色为false
//求左边区间的最后一个点，即上述例题中符合小于等于x的最后一个数字的位置——4
int bsearch 2(intl, int r)
{ 
	while (l < r)
	{
		int mid = l + r + 1 >> 1;//核心，因为更新mid时l=mid;r=mid-1;
		if (check(mid))l = mid;
		else r = mid - 1;
	}
	return l;
}
//注：两模板可能每次划分的区间都不同

浮点数二分

（1）主要思想：

浮点数二分除到区间长度很小时，如 r - l <= 10^(-6)，就可以认为它是一个数了，取 r 或 l 为结果值；

//浮点数二分模板
//求浮点数平方根
#include<iostream>
using namespace std;
int main()
{
	double x;
	cin >> x;
	double l = 0, r = x;
	while (r - l > 1e-8)//精度定位 （比要求输出的小数位数多2，如若题目要求输出结果保留6位小数，则此处精度写1e-8）  
    //或者for(int i=0;i<100;i++)//暴力循环迭代100次
	{
		double mid = (l + r) / 2;
		if (mid = mid >= x)r = mid;
		else l = mid;
	}
	printf("%lf\n", l);
	return 0;
}

注：浮点数二分无需考虑如何整除取整，只会严格的整除一半，因此无需考虑边界问题。

参考第一章基础算法（一） - AcWing