学归并排序和逆序对,这篇文章就够了!!!归并排序和逆序对超详细整理!

1.归并排序

(1).介绍
归并排序是建立在归并操作上的一种有效的排序算法,该算法是采用分治法(DivideandConquer)的一个非常典型的应用。将已有序的子序列合并,得到完全有序的序列;即先使每个子序列有序,再使子序列段间有序。若将两个有序表合并成一个有序表,称为二路归并。

归并排序的时间复杂度是O(nlogn). 速度快,同时归并排序是稳定的排序,即相等的元素的顺序不会改变,如输人记录1(1) 3(2) 2(3) 2(4) 5(5) (括号中是记录的关键字)时输出的1(1) 2(3) 2(4) 3(2) 5(5)中的2和2是按输人的顺序。这对要排序数据包含多个信息而要按其中的某一个信息排序,要求其它信息尽量按输人的顺序排列时很重要,这也是它比快速排序优势的地方。
(2).实现
2-路归并排序的原理是,将序列两两分组,将序列归并为n/2个组,组内单独排序;然后将这些组再两两归并,生成n/4个组,组内再单独排序;以此类推,直到只剩下一个组为止。
下面来看一一个例子,要将序列{66, 12, 33, 57, 64, 27, 18}进行2-路归并排序。

①第一趟。两两分组,得到四组: {66, 12}、 {33,57}、 {64,27}、 {18}, 组内单独排序,得到新序列{12, 66}, {33, 57}, {27, 64}, {18}}.

②第二趟。将四个组继续两两分组,得到两组: {12, 66, 33,57}、{27, 64, 18},组内单独排序,得到新序列{{12, 33, 57, 66}, {18, 27, 64}}.

③第三趟。将两个组继续两两分组,得到一组: {12, 33, 57, 66, 18, 27, 64},组内单独排序,得到新序列{12, 18, 27, 33, 57, 64, 66}。算法结束。
在这里插入图片描述
(3).代码

//归并排序模板
const int maxn = 1e5 + 10;
int a[maxn],b[maxn];
void msort(int l, int r)
{
	if (l == r) return;   //如果只有一个数字则返回,无需排序
	int mid = (l + r) / 2;
	msort(l, mid);       //分解左序列
	msort(mid + 1, r);   //分解右序列
	int i = l, j = mid + 1, k = l;
	while (i <= mid && j <= r)
	{
		if (a[i] <=a[j])
		{
			b[k] = a[i]; k++; i++;
		}
		else
		{
			b[k] = a[j]; k++; j++;
		}
	}
	while (i <= mid)   //复制左边子序列剩余
	{
		b[k] = a[i]; k++; i++;
	}
	while (j <= r)     //复制右边子序列剩余
	{
		b[k] = a[j]; k++; j++;
	}
	for (int i = l; i <= r; i++)
	{
		a[i] = b[i];
	}
}

简化版

const int maxn = 1e5 + 10;
int q[maxn], tmp[maxn];
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 k = l, 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 (int i = l; i <= r; i++) q[i] = tmp[i];
}

2.逆序对

(1).介绍
上述提到归并排序是稳定的排序,相等的元索的顺序不会改变,进而用其可以解决逆序对的问题。首先我们了解一下什么是逆序对。

逆序对:设 A为一个有n个数字的有序集(n>1),其中所有数字各不相同。如果存在正整数i,j使得1≤i<j≤n而且A[i]> A[j].则<A[i],A[j]>这个有序对称为A的一个逆序对,也称作逆序数。

例如,数组(3,1,4,5,2)的逆序对有(3,1),(3,2),(4,2),(5,2),共4个。

所谓逆序对的问题,即对给定的数组序列,求其逆序对的数量。

从逆序对定义上分析,逆序对就是数列中任意两个数满足大的在前,小的在后的组合。如果将这些逆序对都调整成顺序(小的在前,大的在后),那么整个数列就变得有序,即排序。因面,容易想到冒泡排序的机制正好是利用消除逆序来实现排序的,也就是说,交换相邻两个逆序数,最终实现整个序列有序,那么交换的次数即为逆序对的数量。

冒泡排序可以解决逆序对问题,但是由于冒泡排序本身效率不高,时间复杂度为O(n^2),对于n比较大的情况就没用武之地了。我们可以这样认为,冒泡排序求逆序对效率之所以低,是因为其在统计逆序对数量的时候是一对一对统计的,而对于范围为n的序列,逆序对数量最大可以是(n+1)*n/2,因此其效率太低.那怎样可以一下子统计多个,而不是一个一个累加呢?这个时候,归并排序就可以帮我们来解决这个问题。
在合并操作中,我们假设左右两个区间元素为:

左边:{3 4 7 9} 右边:{1 5 8 10}

那么合并操作的第一步就是比较3和1,然后将1取出来放到辅助数组中,这个时候我们发现,右边的区间如果是当前比较的较小值,那么其会与左边剩余的数字产生逆序关系,也就是说1和3、4、7、9都产生了逆序关系,我们可以一下子统计出有4对逆序对。接下来3,4取下来放到辅助数组后,5与左边剩下的7、9产生了逆序关系,我们可以统计出2对。依此类推,8与9产生1对,那么总共有4+2+1对。这样统计的效率就会大大提高,便可较好地解决逆序对问题。

而在算法的实现中,我们只需略微修改原有归并排序,当右边序列的元素为较小值时,就统计其产生的逆序对数量,即可完成逆序对的统计。.

(2).代码

const int maxn = 1e5 + 10;
int q[maxn], tmp[maxn];
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 k = l, i = l, j = mid + 1;
	while (i <= mid && j <= r)   //合并
	{
		if (q[i] <= q[j]) tmp[k++] = q[i++];
		else 
		{
		    tmp[k++] = q[j++];
		    ans += mid - i + 1;   //统计产生逆序对的数量
		}
	}
	while (i <= mid) tmp[k++] = q[i++];   //复制左边子序列剩余
	while (j <= r) tmp[k++] = q[j++];    //复制右边子序列剩余
	for (int i = l; i <= r; i++) q[i] = tmp[i];
}

其中,ans+=mid-i+1 这句代码统计新增逆序对的数量,ans作为全局变量,用于统计逆序对的数量,此时ans要增加左边剩余元素的个数。当归并排序结束后,逆序对也得到解决,ans即为逆序对的数量。

3.例题

(1).题目
给定一个长度为n的整数数列,请你计算数列中的逆序对的数量。

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

输入格式
第一行包含整数n,表示数列的长度。

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

输出格式
输出一个整数,表示逆序对的个数。

数据范围
1≤n≤100000
输入样例:
6
2 3 4 5 6 1
输出样例:
5

//归并排序模板
#include<iostream>
#include<cstdio>
using namespace std;
const int maxn = 1e6 + 10;
int q[maxn], tmp[maxn];
long long ans = 0;
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 k = l, i = l, j = mid + 1;
	while (i <= mid && j <= r)   //合并
	{
		if (q[i] <= q[j]) tmp[k++] = q[i++];
		else
		{
			tmp[k++] = q[j++];
			ans += mid - i + 1;
		}
	}
	while (i <= mid) tmp[k++] = q[i++];   //复制左边子序列剩余
	while (j <= r) tmp[k++] = q[j++];    //复制右边子序列剩余
	for (int i = l; i <= r; i++) q[i] = tmp[i];
}
int main()
{

	int n;
	cin >> n;
	for (int i = 0; i < n; i++)
	{
		cin >> q[i];
	}
	merge_sort(q, 0, n - 1);
	cout << ans << endl;
	return 0;
}

参考书籍:《信息学奥赛一本通》,《算法笔记.胡凡》,将其中讲解的很好的内容搬运过来并加以整理,方便各位对归并排序和逆序对的学习。

<think>嗯,用户让我介绍一下归并排序逆序对的代码。首先,我需要回忆一下归并排序的基本原理,以及逆序对的定义。归并排序是分治算法,把数组分成两半,分别排序后再合并。而逆序对指的是数组中前面的元素大于后面的元素的情况。例如,在数组[3,1,2]中,逆序对有(3,1)(3,2),所以总共有2个。 那归并排序过程中如何计算逆序对呢?在合并两个已排序的子数组时,如果左边的元素大于右边的元素,那么左边该元素及其后面的元素都会与右边的这个元素构成逆序对。例如,合并时左边是[3,4],右边是[1,2],当比较31时,3>1,所以逆序对的数量应该是左边剩余元素的数量(这里左边此时有2个元素),所以逆序对增加2。这一步是关键,需要正确统计这个数量。 接下来,我需要考虑如何修改归并排序的代码来统计逆序对的数量。通常归并排序的合并过程需要临时数组,然后在合并时进行比较。这时候,当右边的元素被选中放入临时数组时,说明左边的当前元素比右边的大,这时候逆序对的数量需要加上左边剩余元素的个数,也就是mid - i + 1,其中i是左边子数组的当前指针,mid是左边子数组的末尾。 可能的代码结构应该是这样的:主函数调用一个递归函数,该函数返回逆序对的数量。递归函数先分割数组到单个元素,然后合并并统计逆序对的数量。合并过程中,每次从左右子数组中取较小的元素,当取右子数组的元素时,累加逆序对的数量。 需要注意的点包括:数组的索引是否正确,例如mid的计算,以及临时数组的处理。另外,逆序对的累加应该在合并过程中正确计算。例如,当左边元素大于右边元素时,逆序对的数量增加左边剩余元素的数目。 举个例子,比如数组是[5,3,2,4,1]。用归并排序分割到最小单位后,合并时计算逆序对。比如在合并[5][3]的时候,5>3,所以逆序对加1。合并后的数组是[3,5],然后再合并更大的部分,每一步都要统计这些情况。 可能还要考虑大数情况下的性能,因为如果数组很大,递归可能导致栈溢出,但通常归并排序在处理大规模数据时还是可以的,因为时间复杂度是O(n log n),而逆序对的计算不会增加复杂度,只是常数时间上的增加。 另外,边界条件需要注意,比如数组长度为0或1时,逆序对数量为0。测试用例方面,可以测试已知的情况,比如数组倒序排列时逆序对数量最大,为n(n-1)/2。例如,数组[4,3,2,1]的逆序对数是6。 在代码实现时,可能需要注意数组的索引是否正确,比如在分割时左半部分是left到mid,右半部分是mid+1到right。合并过程中,i指向左半部分的起始,j指向右半部分的起始,当nums[i] > nums[j]时,逆序对数目加上mid - i + 1。因为此时左半部分从i到mid的所有元素都会比nums[j]大,所以贡献mid - i +1个逆序对。 所以,总结下来,归并排序逆序对的代码结构大致如下: 定义一个全局或传递的计数器,或者在递归过程中返回逆序对数目。合并函数返回本次合并中的逆序对数目,然后递归地将左右子数组的数目相加,再加上合并过程中的数目。 具体的代码实现可能需要使用辅助数组来存放合并后的结果,同时在合并过程中统计逆序对的数量。递归函数的结构可能类似: def merge_sort(nums, left, right): if left >= right: return 0 mid = (left + right) // 2 count = merge_sort(nums, left, mid) + merge_sort(nums, mid+1, right) count += merge(nums, left, mid, right) return count 其中merge函数负责合并并返回该次合并中的逆序对数目。merge函数中,当左半部分的元素大于右半部分时,累加mid - i + 1到count中。 编写merge函数时,需要创建临时数组,然后比较左右两部分的元素,按顺序放入临时数组,同时统计逆序对的数量。例如: def merge(nums, left, mid, right): temp = [] i = left j = mid + 1 count = 0 while i <= mid and j <= right: if nums[i] <= nums[j]: temp.append(nums[i]) i += 1 else: temp.append(nums[j]) count += mid - i + 1 j += 1 # 处理剩余元素 temp.extend(nums[i:mid+1]) temp.extend(nums[j:right+1]) # 将临时数组复制回原数组 nums[left:right+1] = temp return count 这样,在每次合并的时候,当右半部分的元素被选中时,累加对应的逆序对数目。整个归并排序完成后,累计的count就是总的逆序对数目。 需要注意的地方是原数组会被修改,所以如果需要保留原数组,可能需要先复制一份。例如,在调用的时候,可以复制数组,然后对复制的数组进行排序计算。 例如,主函数可能是: def count_inversions(nums): # 复制原数组,避免修改原数组 temp_nums = nums.copy() return merge_sort(temp_nums, 0, len(temp_nums)-1) 测试的时候,比如输入[3,1,2],应该返回2。输入[1,2,3,4]返回0,输入[4,3,2,1]返回6。 可能的错误点包括: 1. 索引计算错误,比如mid的计算是否正确,是否导致分割错误。 2. 在合并时,i的范围是left到mid,j是mid+1到right,所以在处理剩余元素的时候,应该用nums[i:mid+1],而不是到mid,因为切片是左闭右开的,所以mid+1作为结束索引可以包含到mid的元素。 3. 修改原数组的部分是否正确,即nums[left:right+1] = temp,因为right是包含的,所以切片结束是right+1。 另外,关于空间复杂度,归并排序需要O(n)的额外空间,这在处理大数组时可能需要注意。 现在,综合这些思考,可以编写出正确的归并排序逆序对的代码。</think>以下是使用归并排序计算逆序对的中文代码实现及详细解释: ### 代码实现 ```python def count_inversions(nums): def merge_sort(arr, left, right): if left >= right: return 0 mid = (left + right) // 2 # 分治递归计算左右子数组的逆序对 count = merge_sort(arr, left, mid) + merge_sort(arr, mid+1, right) # 合并过程并统计逆序对 count += merge(arr, left, mid, right) return count def merge(arr, left, mid, right): temp = [] # 临时合并数组 i, j = left, mid+1 count = 0 # 当前合并步骤的逆序对计数 # 左右子数组均未遍历完时比较 while i <= mid and j <= right: if arr[i] <= arr[j]: temp.append(arr[i]) i += 1 else: temp.append(arr[j]) # 关键统计逻辑:左半数组剩余元素都与arr[j]构成逆序对 count += mid - i + 1 j += 1 # 处理剩余元素 temp.extend(arr[i:mid+1]) # 左半剩余 temp.extend(arr[j:right+1]) # 右半剩余 # 将合并结果写回原数组 arr[left:right+1] = temp return count # 创建副本避免修改原数组 return merge_sort(nums.copy(), 0, len(nums)-1) # 测试示例 print(count_inversions([3, 1, 2])) # 输出: 2 print(count_inversions([5, 3, 2, 4, 1])) # 输出: 7 print(count_inversions([4, 3, 2, 1])) # 输出: 6 ``` --- ### 核心原理 1. **分治策略** - 将数组递归拆分为左右两半,分别计算各自的逆序对数量。 - 合并时统计跨越左右子数组的逆序对。 2. **关键合并逻辑** - 当右子数组元素被放入临时数组时,左子数组剩余的所有元素均与该元素构成逆序对。 - 计算公式:`逆序对增量 = mid - 当前左指针 + 1` --- ### 复杂度分析 - **时间复杂度**:O(n log n) 与归并排序相同,合并过程总计执行 log n 层,每层处理 n 个元素。 - **空间复杂度**:O(n) 临时数组存储合并结果。 --- ### 关键点说明 - **原数组保护**:通过`nums.copy()`避免修改输入数据。 - **索引计算**:`mid`值为`(left + right)//2`确保分割正确。 - **剩余元素处理**:使用`extend()`直接添加未遍历完的子数组。 此算法高效且优雅地利用归并排序的特性,在排序过程中同步完成逆序对统计。
评论 5
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

林小鹿@

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值