排序、二分及分治

目录

排序

冒泡排序：

桶排序：

std::sort():

sort()对于结构体排序（运算符重载）

二分

分治

归并排序：

---

排序

顾名思义，对一个无序数组按照升序或降序进行排列

排序方法很多：冒泡、选择、插入、归并、快排、堆、桶排....

这里只介绍冒泡排序、桶排序、stl中的sort函数(堆排+快排) 以及后面会提到的归并排序

冒泡排序：

假设按照数据升序排列，如果一个数a比另一个数b大，那么a排序后的位置应该在b后面

根据以上思路，每次可以对比相邻的两个数，如果后者比前者大就交换他们的位置

每一轮操作可以固定一个数（最大），n轮操作后就会完成排序

优化：如果一轮操作中没有一次交换，则表明该数组已经排好序，可直接结束

时间复杂度O(n^2)

void sort()
{
	for(int i = 1;i < n;i++)
	{
		bool flag = true;
		for(int j = 1;j <= n-i;j++)
		{
			if(a[j] > a[j+1])
			{
				flag = false;
				swap(a[j],a[j+1]);
			}
		}
		if(flag) break;
	}
}

桶排序：

如果一组数据只需要得到他们的排序结果，在数据的值小于一定范围时可以使用该排序

假设有n个数，每个数的范围都在[0,100]，那么可以记录每个数出现的次数a[i]

其中a[i]表示数i出现的次数，最后从头开始遍历数组可以按顺序得到所有的数

时间复杂度O(n)，空间复杂度O(max(x))，x为输入的最大值

void sort()
{
	for(int i = 1;i <= n;i++)
	{
		int x;
		cin >> x;
		a[x]++;
	}
	for(int i = 0;i <= 100;i++)
	{
		//表示第i个数有a[i]个 
		for(int j = 1;j <= a[i];j++)
		{
			cout << i << " ";
		}
	}
}

std::sort():

sort()函数在<algorithm>库中

参数：sort(begin,end,cmp)

begin为待排序数组的第一个存放有效数据的位置，end为待排序数组的最后一个有效数据位置+1

cmp为比较函数，返回值为真则表示交换两数，假则不交换，默认为升序排列

注意重写cmp函数的时候不要出现有等于号且返回为真的情况，此时会不断交换相邻的两个相同的数造成出错

sort()函数复杂度：nlog(n)

bool cmp(int a,int b)
{
    //a < b为真否则为假
	return a < b;
}
int main()
{
	cin >> n;
	for(int i = 1;i <= n;i++)
	{
		cin >> a[i];
	}
    //默认升序排序
	sort(a+1,a+1+n);
	for(int i = 1;i <= n;i++)
	{
		cout << a[i] << " ";
	}
    //重写cmp函数，改为降序排序
	sort(a+1,a+1+n,cmp);
	for(int i = 1;i <= n;i++)
	{
		cout << a[i] << " ";
	}
	return 0;
}

sort()对于结构体排序（运算符重载）

operator：C++的一个关键字，和运算符一起使用，表示一个运算符重载函数

一般是重载小于号，也就是更改一下结构体间使用的小于号的定义

struct node{
	int x,y;
	//x大的在前，x相同则y大的在前 
	bool operator < (const node& p) node
	{
		//建议使用三目运算符方便好写 
		return x == p.x ? y > p.y : x > p.x;
		//if(x == p.x) return y > p.y;
		//else return x > p.x;
	}
}a[100010];
int main()
{
	ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
	cin >> n;
	for(int i = 1;i <= n;i++)
	{
		cin >> a[i].x >> a[i].y;
	}
	sort(a+1,a+1+n);
	for(int i = 1;i <= n;i++)
	{
		cout << a[i].x << " " << a[i].y << "\n";
	}
	return 0;
}

二分

前提：数据有序（可以用排序实现）

找出某个数的位置或第一个大于(小于)等于该数的位置这类问题，可以通过二分来实现

原理(以升序为例)：

• 若要找到目标数p，在保证数据有序的情况，先找出中间的一个数m
• 若该数符合要找的数则返回，若不符合该数则比较p和m的大小
• 若p > m则表明p在m之后，可以去后半数组中寻找
• 若p < m则表明p在m之前，可以去前半数组中寻找

重复该操作，直到找到为止

由于每次都是找中间的位置，舍去了数组一半的长度，所以复杂度为nlog(n)

int check(int p)
{
	//找到第一个大于等于p的位置 
	int res = -1; 
	int l = 1,r = n;
	while(l <= r)
	{
		int mid = (l+r)/2;
		if(p >= a[mid])
		{
			res = mid;
			r = mid - 1;
		}
		else
		{
			l = mid + 1;
		}
	}
	return res;
}

此外，还有stl中的函数：

以下[x,y)为左闭右开

• std::upper_bound(begin,end,p) 返回[ a[begin],a[end] )中第一个严格大于p的数的迭代器
• std::lower_bound(begin,end,p) 返回[ a[begin],a[end] )中第一个大于等于p的数的迭代器

分治

某些问题在数据很多时处理起来非常复杂，但数据较小时处理却非常简单

此时可以把问题分解为若干个子问题，最后将解合并

一般该类问题分解的子问题相互独立，不存在公共子问题（会重复求解）

一般分治都是将问题不断分为左右两半分别求解，答案规模从1→2→4→8....复杂度为nlog(n)

上面提到的归并排序就是利用分治的思想

归并排序：

以升序为例

把一个序列分成若干个子序列，当子序列长度为1时保证序列是有序的

将子序列按照分解方式返回并且两两合并，合并时按照顺序进行交换

由于两个子序列有序，所以可以每次比较两个子序列未被合并的数据，优先纳入较小的

最终合并完的序列即为排好序的序列

复杂度为nlog(n)

int a[500010];
int b[500010];
void M(int l,int mid,int r)
{
    //i为左子序列的起点,r为右子序列的起点,mid为左子序列的终点
	int i = l,j = mid+1,k = l;
	while(i <= mid && j <= r)
	{
        //左边值大于右边则将右边放入备用数组b
		if(a[i] > a[j])
		{
			b[k++] = a[j++];
		}
        //否则将左边放入备用数组b
		else
		{
			b[k++] = a[i++];
		}
	}
    //两个while循环排序两个子序列放在b中
	while(i <= mid)
	{
		b[k++] = a[i++];
	}
	while(j <= r)
	{
		b[k++] = a[j++];
	}
    //将排好序的b复制回a中
	for(i = l;i <= r;i++)
	{
		a[i] = b[i];
	}
}
void Ms(int l,int r)
{
	if(l < r)
	{
        //折半分治左右两边
		int mid = (l+r)/2;
		Ms(l,mid);
		Ms(mid+1,r);
		M(l,mid,r);
	}
}