36-数组中的逆序对

最新推荐文章于 2024-11-24 11:12:23 发布

最新推荐文章于 2024-11-24 11:12:23 发布 · 191 阅读

文章标签：

#剑指offer

剑指Offer 专栏收录该内容

28 篇文章

订阅专栏

本文介绍了一种利用归并排序思想计算数组中逆序对数量的方法。通过递归分解数组，并在合并过程中统计逆序对，最终得出整个数组的逆序对总数。此外，还附带实现了归并排序算法。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

用到了归并排序的思想，有关归并排序：

白话经典算法系列之五归并排序的实现

如果前半部分的数组中一个数大于后半部分的某个数，因为子数组是排好序的，所以肯定大于后半部分某数之前的全部数，即j-mid，见代码中，这就是i对应的逆序数目。

class Solution {
public:
    long long  InversePairsCore(vector<int>& data, vector<int>& copy, int start, int end)
{
	if (start == end)
		return 0;
	long long mid = (start + end) >>1;
	long long  left = InversePairsCore( copy,data, start, mid);  //这里把copy和data换了一下位置，滚动数组的思想？
	long long  right = InversePairsCore( copy,data, mid + 1, end);

	long long  i = mid;
	long long  j = end;
	long long  indexcopy = end;
	long long  count = 0;
	while (i >= start && j > mid)
	{
		if (data[i] > data[j])
		{
	
			copy[indexcopy--] = data[i--];
		    count += j - mid;                      //见上方黑粗字
		}
		else
			copy[indexcopy--] = data[j--];

	}
	while (i >= start)
		copy[indexcopy--] = data[i--];
	while (j > mid)
		copy[indexcopy--] = data[j--];
    //for(int s=start;s<=end;s++)
     //   data[s]=copy[s];

	return left + right + count;

}

int InversePairs(vector<int> data)
{


	auto t = data.size();
	if (t == 0)
		return 0;
	vector<int> copy(data);
	long long count = InversePairsCore(data, copy, 0, t-1);
	copy.clear();
	return count % 1000000007;

}
};

自己写个归并排序：

void Merge(int data[], int copy[], int start, int end,int mid)
{

	int i = start;
	int  j = mid+1;

	int k = 0;
	while (i <= mid && j <=end)
	{
		if (data[i] < data[j])
		{

			copy[k++] = data[i++];

		}
		else
			copy[k++] = data[j++];

	}
	while (i <= mid)
		copy[k++] = data[i++];
	while (j <= end)
		copy[k++] = data[j++];

	for (int i = 0; i < k;i++)
	{
		data[start + i] = copy[i];
	}
}


void mergesort(int data[], int copy[], int start, int end)
{
	if (start < end)
	{
		int mid = (start + end) >> 1;
		mergesort(data, copy, start, mid);
		mergesort(data, copy, mid + 1, end);
		Merge(data, copy, start, end,mid);
	
	
		

	}
}

bool mergesort(int a[],int n)
{

	int *p = new int[n];

	if (p == NULL)
		return false;
	mergesort(a,p, 0, n - 1);
	delete[] p;
	return true;
}