逆序对之树形数组与归并排序

最新推荐文章于 2021-11-29 00:17:01 发布
最新推荐文章于 2021-11-29 00:17:01 发布
阅读量5.5k 收藏 3
点赞数
分类专栏： 算法 C语言 算法鸣泣之时 文章标签： 算法 归并排序 树形数组 逆序对
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ii1245712564/article/details/42344621
版权

1.逆序对问题

逆序对，何为逆序对？逆序对就是在一序列array[]中，其中存在两个元素array[i]和array[j]，满足下列关系： i<j其中i>=0 j<array.length 且 array[i]>array[j]，这一对数(array[i] , array[j])就是逆序对，要是给定一个任意的序列，那怎么求逆序对的数量呢？
求解该问题有两个经典的方案：
  • 基于树状数组来求解
  • 在归并排序的基础上求解
下面我们将慢慢介绍这两种算法：

2.逆序对之树状数组

2-1.树状数组

2-1-1.树状数组介绍

我们首先介绍一下什么是树状数组，树状数组顾名思义就是结构上长的很像树的数组，如下图：

图中这个红色的数组C[i](注意：下标从1开始)即为树状数组,下面的A[i]为一般的数组，C[i]是基于A[i]的基础上建立起来的，是为了来描述A[i]若干个连续元素之和，之间的对应的关系为：
C[1] = A[1]
C[2] = A[1]+A[2]
C[3] = A[3]
C[4] = A[1]+A[2]+A[3]+A[4]
C[5] = A[5]
...
C[i]=A[i-lowbit(i)+1]+A[i-lowbit(i)+2]+...+A[i]，里面的的lowbit()是什么呢？
我们不妨观察一下

十进制二进制尾部零的个数对应层数相加元素个数
110个最底层1(2^0)
2101个倒数第二层2(2^1)
3110个最底层1(2^0)
41002个倒数第三层4(2^2)
51010个最底层5(2^0)

...
所以就设对应的数组下标为i，其二进制尾部零的个数为n，那么lowbit() = 2^n

2-1-2.树状数组的用途

由上面的分析可见，树状数组C[i]的值是A[i]里面的若干个连续的元素相加得到的，所以树状数组是用于在数组A中，里面的元素有可能不断的被更改，但是能高效的求出前数组A里面的前n项和，因为一般方法数组一旦更改了其中一个元素，比如A[0]被更改了，所有的前N项和都要更改，牵一发而动全身，而且更改代价为O(n^2)，那么有没有更快速的方法呢？有！那就是树状数组，可以在(nlogn)的代价内完成更改，下面慢慢道来。

2-1-3.树状数组的基本操作

lowbit(i)的求解 
int lowbit(const int indexNumber)
{
	return indexNumber&(-indexNumber);
	//这里采用补码的思想
}
但是为什么是n~(-n)呢？
证明：假设n的二进制表示为：a1b其中‘1’是第一个‘1’ ，b表示全为零的部分，-n就表示成补码的形式（取反加一）A0B+1=A1b，于是n&(-n)=(a1b)&(A1b)，因为A，a互为反码，那么最后结果就为1b,即为2^n,证毕！

求前N项和
我们之前分析过C[i]=A[i]之间的对应关系，那么要是数组A的前N项和SUM[i]和C[i]之间有时什么关系呢？
SUM[1]=C[1];
SUM[2]=C[2];
SUM[3]=C[2]+C[3];
SUM[4]=C[4]；
SUM[5]=C[4]+C[5];
...
推出一般情况
SUM[i]=C[i]+C[i-lowbit(i)]+...+C[j](j>0)
代码如下：（因为树状数组要从1开始，那么我就将空出来的treeArray[0]存储树状数组的长度） 
//计算前N1到N2之间的元素的和
int getSumN(const int treeArray[] ,int index)
{
	if(index < 1 || index > treeArray[0])//treeArray[0]为树状数组的长度
	{
		fprintf(stderr, "%s\n","wrong array index" );
		return 0;
	}
	int sum=0;
	while(index > 0)
	{
		sum += treeArray[index];
		index -= lowbit(index); 
	}
	return sum;
}

树状数组更新操作
那要是A数组里面的一个元素A[i]发生了变化，那么对应的树状数组该如何变化呢？不妨回顾之前的A[i]和C[i]的对应关系，便可得知，一旦A[i]发生了变化，基于A[i]累加起来的树状数组的那些项都需要变化，从图上来看就是一旦一个儿子节点发生变化，其双亲节点直到根节点都需要加上变化值 
// index表示更行的那个数组的索引
void updateTreeArray(int treeArray[],int index , const int value)
{	
	// 其中treeArray[0]表示了数组的长度
	while(index <=treeArray[0])//将所有的父节点更新
	{
		treeArray[index]+=value;
		index+=lowbit(index);
	}
	return ;
}

2-2.基于树状数组的逆序对求解

前面我们介绍了树状数组，现在我们开始正题
一开始我怎么都不会觉得树状数组和逆序对扯得上关系，后来网上查了一下，发现还真有巧妙的办法，树状数组最大的用途是什么？就是以nlogn的代价来求出前n项和，那么我们将序列里面的数一个一个的插入到初始化为0的树状数组C里面，每插入一个，那么就统计比自己小的元素有多少个（这里就是前N项和），并将插入位置i的A[i]加一，更新整个树状数组！这里理解起来有点抽象，那么我们就先抛开树状数组，假设有一序列inputArray {5,2,1,4,3}，有序列A{0,0,0,0,0} 

A{0,0,0,0,0}      ---插入5---> A{0,0,0,0,1}，现在比5小的数为0
A{0,0,0,0,1}     ---插入2---> A{0,1,0,0,1}，现在有两个元素，但  是比2小的元素个数为0，那么说明比2大的元素有1个
A{0,1,0,0,1} ---插入1--->A{1,1,0,0,1}，现在有三个元素，但是比1小的元素为0，那么说明比1大的元素有2个
。。。以此类推
只不过我们将统计比当前元素小的元素个数交给了树状数组

要实现将树状数组求逆序对，要进行两个步骤：
  • 将输入数组离散化
  • 离散化以后输入到一个树状数组里面，求逆序对数量

2-2-1.离散化

其实我们不将数组离散化也可以实现，但是因为树状数组对于下标有着严格的要求，一方面为了操作的方便，另一方面为了节省内存，所以我们选择将数组离散化，比如输入序列为{1,9999,10000},如果不离散化该数组，那么在树状数组里面将需要申请10000个节点元素，这样是不划算的,要是我们离散化该序列以后，那么输入序列将为{1,2,3}...这样节省了空间，又操作简便，下面给出离散化的步骤：

1.定义一个结构体

struct disrect_s
{
	int value;//数组元素的值
	int index;//数组元素位置标号
};

2.将输入数组的值赋值给一个struct disrect_s类型的数组

struct disrect_s disrectArray[arrayLength];
int i;
//赋值
for (i = 0; i < arrayLength; ++i)
{
	disrectArray[i].value = inputArray[i];
	disrectArray[i].index=i;
}
3.以value值排序disrectArray数组(注意这里排序一定要选一个nlogn代价的算法来排序，比如快排，归并排序等等，此处现则归并排序) 

//以nlogn来排序
mergeSort(disrectArray , arrayLength);
4.还原之前的标号，并将标号放入一个数组里面 

int tempArray[arrayLength];
for(i=0 ; i<arrayLength ;++i)
{
    tempArray[disrectArray[i].index]=i+1;
}
这个时候离散化完毕

比如输入一个数组为{9,1,0,5,4}，那么离散化就为{5,2,1,4,3}


2-2-2.将元素插入树状数组里面去

现在需要把temparray里面的元素从零开始一个一个的插入到树状数组里面去（注意数组的相对大小位置没有发生改变），具体代码如下：

int reversePairCount=0;
/*...*/
//一个一个的插入到树状数组里面去
createTreeArray(&treeArray,NULL,arrayLength);
for (i = 0; i < arrayLength; ++i)
{
	// fprintf(stderr, "%s+++%d\n","Hello1",tempArray[i] );
	updateTreeArray(treeArray,tempArray[i],1);
	reversePairCount+=(i+1-getSumN(treeArray , tempArray[i]));//加上每个对应逆序对的数量
       // fprintf(stderr, "%s\n","Hello2" );
}
//reversePairCount就是逆序对的数量

树状数组完整代码请见文章末尾。

3.逆序对之归并排序

现在要将的算法就比之前的树状数组简单不知多少了，也没有那么头疼了，在讲归并排序求逆序对之前我们不妨来看一个例子:

现在有序列A1={2,5,7,8} A2={1,4,6,9} A={A1,A2};其中A1升序，A2升序，那我们怎么来求解A里面的逆序对数量呢？因为A1升序，A2升序，所以A1，A2中不可能存在逆序对，那么逆序对(number1, number2)如果存在，那么只有可能一个输存在A1中,一个数存在A2中，现在只需要按顺序来取出A1,A2里面的元素来进行比较

在两个数组下标i,j都还未达到数组末尾时，两个比较无非又两种情况：

  1. A1[i]>A2[j],逆序对，那么此时将将reversePairCount++,然后++j;
  2. A1[i]<=A2[j]，非逆序对,++i；

当其中有一个数组为空时，也只有两种情况：

  1. i==A1.arrayLength;此时逆序对不可能存在了
  2. j==A2.arrayLength；剩余在A1里面的数全都是A2里面元素的的逆序对，既剩余个数为：reversePairCount+=(leftSubArrayLength-i-1)*rightSubArrayLength;


注意比较一下归并排序，归并排序的每一次操作都是基于上一次操作返回的两个有序的子序列上进行的，现在我们就在归并排序的过程中顺道解决一下逆序对的问题，具体代码如下：

#include <stdio.h>
#include <stdlib.h>


//通过归并排序来计算逆序对的数量
int MERGE(int subArray[] , const int left , const int right)
{
	if(left >= right)
		return 0;
	int reversePairCount = 0;
	int i ,j,k;
	int center = (left+right)/2;
	//计算左边和右边的逆序对的总数
	reversePairCount+=MERGE(subArray , left , center);
	reversePairCount+=MERGE(subArray , center+1 , right);
	//左右边的子数组
	const int leftSubArrayLength = center-left+1;
	const int rightSubArrayLength = right-center;
	int leftSubArray[leftSubArrayLength];
	int rightSubArray[rightSubArrayLength];

	for(i=0;i<leftSubArrayLength;++i)
	{
		leftSubArray[i]=subArray[left+i];
	}
	for(j=0;j<rightSubArrayLength;++j)
	{
		rightSubArray[j]=subArray[j+center+1];
	}

	i=0;j=0;k=0;
	while(i<leftSubArrayLength && j<rightSubArrayLength)
	{
		if(leftSubArray[i]>rightSubArray[j])
		{
			subArray[k+left]=rightSubArray[j++];
			reversePairCount++;
			++k;
		}
		else
		{
			subArray[k+left]=leftSubArray[i++];
			++k;
		}
	}
	//辨别哪一个数组为空了
	if(j==rightSubArrayLength)//右边数组空了
	{
		reversePairCount+=(leftSubArrayLength-i-1)*rightSubArrayLength;
		while(i<leftSubArrayLength)
		{
			subArray[k+left] = leftSubArray[i];
			++k;
			++i;
		}
	}
	else
	{
		while(j<rightSubArrayLength)
		{
			subArray[k+left]=rightSubArray[j];
			++k;
			++j;
		}
	}
	//剩下的元素基体搬家
	return reversePairCount;
}

int reversePair(const int inputArray[] , const int arrayLength)
{
	int tempArray[arrayLength];//为了不破坏原数组的元素位置，申请一个新的数组
	int i=0;
	int count;
	for(i=0;i<arrayLength ; ++i)
	{
		tempArray[i]=inputArray[i];
	}
	count=MERGE(tempArray , 0 , arrayLength-1);
	for(i=0;i<arrayLength;++i)
	{
		printf("%d\t", tempArray[i]);
	}
	printf("\n" );
	return count;
}


int main(int argc, char const *argv[])
{
	int array[]={9,1,0,5,4};
	printf("reverse pair number is:%d\n",reversePair(array , sizeof(array)/sizeof(int)));
	return 0;
}


下面时树状数组求逆序对的代码：

treeArray.h

#ifndef _TREEARRAY_H
#define _TREEARRAY_H

//树状数组的通用接口

struct treeArray_t
{
	int * node;	
	int treeLength;
};

typedef struct treeArray_t * TreeArray;


static int lowbit(const int number)
{
	  return number&(-number);
}

//创建一个数组并将其初始化
void createTreeArray( TreeArray * treeArrayPtr , const int inputArray[] , const int arrayLength);
//更新一个树状数组
void updateTreeArray(TreeArray treeArray ,int index , const int num );
//求前n项和的值
int getSumN(TreeArray treeArray , int index );
//销毁一个树状数组
void destoryTreeArray(TreeArray treeArray);
//打印一个treearray
void printTreeArray(const TreeArray treeArray);


#endif

treeArray.c

#include "treeArray.h"
#include <stdio.h>
#include <stdlib.h>

void createTreeArray(TreeArray * treeArrayPtr  , const int inputArray[] , const int arrayLength)
{
	if(arrayLength <=0)
	{
		fprintf(stderr, "%s\n", "array Length should greater than 0 " );
		return;
	}
	int i=0;
	(*treeArrayPtr) = (TreeArray)malloc(sizeof(struct treeArray_t));
	if((*treeArrayPtr) == NULL)
	{
		fprintf(stderr, "%s\n","Out of space!");
		exit(EXIT_FAILURE);
	}
	(*treeArrayPtr)->node = (int *)malloc(sizeof(int)*(arrayLength+1));
	if((*treeArrayPtr)->node == NULL)
	{
		fprintf(stderr, "%s\n","Out of space!");
		exit(EXIT_FAILURE);		
	}
	(*treeArrayPtr)->treeLength = arrayLength+1;

	//下面开始为树状数组赋值
	if(inputArray == NULL)//默认将全部的树状数组初始化为0
	{
		for ( i = 1; i < (*treeArrayPtr)->treeLength; ++i)
		{
			(*treeArrayPtr)->node[i]=0;
		}
	}
	else
	{
		for ( i = 1; i < (*treeArrayPtr)->treeLength; ++i)
		{
			int sum=0;
			int j;
			for ( j = i-lowbit(i)+1; j <=i; ++j)
			{
				sum+=inputArray[j-1];
			}
			(*treeArrayPtr)->node[i]=sum;
		}
	}
}


void updateTreeArray(TreeArray treeArray , int index ,const int num)
{
	if(treeArray==NULL)
		return;
	while(index <= treeArray->treeLength)
	{
		treeArray->node[index]+=num;
		index +=lowbit(index);
	}
}

int getSumN(TreeArray treeArray , int index)
{
	if(treeArray==NULL)
		return;
	int sum=0;
	while(index >0)
	{
		sum+=treeArray->node[index];
		index -=lowbit(index);
	}
	return sum;
}

void destoryTreeArray(TreeArray treeArray)
{
	if(treeArray==NULL)
		return;
	free(treeArray->node);
	free(treeArray);
	treeArray=NULL;
}


void printTreeArray(const TreeArray treeArray)
{
	if(treeArray==NULL)
		return;
	int i;
	for (i = 1; i < treeArray->treeLength; ++i)
	{
		printf("%d\t",treeArray->node[i]);
		// printf("%d\t",getSumN(treeArray , i));
		fflush(stdout);
	}
	printf("\n");
}

reversePair.h

#ifndef _REVERSEPAIR_H
#define _REVERSEPAIR_H

#include "treeArray.h"

struct disrect_s
{
	int value;
	int index;
};


void MERGE(struct disrect_s subArray[] , const int left , const int right);
void mergeSort(struct disrect_s inputArray[] , const int arrayLength);
//计算逆序对的数量
int reverserPairNumber(const int inputArray[] , const int arrayLength);


#endif

reversePair.c

#include "reversePair.h"
#include <stdio.h>
#include <stdlib.h>
#include <limits.h>

void MERGE(struct disrect_s subArray[] , int left , int right)
{
	if(left >= right)
		return;
	int mid = (left+right)/2;

	MERGE(subArray , left , mid);
	MERGE(subArray , mid+1 , right);

	int i=0;
	int j=0;
	int k=0;

	int leftSubArrayLength=mid-left+2;
	int rightSubArrayLength = right-mid+1;
	struct disrect_s leftSubArray[leftSubArrayLength];
	struct disrect_s rightSubArray[rightSubArrayLength];

	for(i=0;i<leftSubArrayLength-1;++i)
	{
		leftSubArray[i]=subArray[left+i];
	}
	for(j=0;j<rightSubArrayLength-1;++j)
	{
		rightSubArray[j]=subArray[mid+1+j];
	}
	leftSubArray[leftSubArrayLength-1].value=INT_MAX;
	rightSubArray[rightSubArrayLength-1].value=INT_MAX;
	//merge
	i=0;
	j=0;
	for(k=left;k<=right;++k)
	{
		if(leftSubArray[i].value<=rightSubArray[j].value)
		{
			subArray[k]=leftSubArray[i];
			++i;
		}
		else
		{
			subArray[k]=rightSubArray[j];
			++j;
		}
	}
	return;
}


void mergeSort(struct disrect_s inputArray[] , const int arrayLength)
{
	MERGE(inputArray , 0 , arrayLength-1);
}


int reverserPairNumber(const int inputArray[] , const int arrayLength)
{
	TreeArray treeArray=NULL;
	struct disrect_s disrectArray[arrayLength];
	int reversePairCount=0;

	int tempArray[arrayLength];
	int i;
	//赋值
	for (i = 0; i < arrayLength; ++i)
	{
		disrectArray[i].value = inputArray[i];
		disrectArray[i].index=i;
	}
	//以nlogn来排序
	mergeSort(disrectArray , arrayLength);

	for(i=0 ; i<arrayLength ;++i)
	{
		tempArray[disrectArray[i].index]=i+1;
	}
	for (i = 0; i < arrayLength; ++i)
	{
		printf("%d\t", tempArray[i]);
	}
	//一个一个的插入到树状数组里面去
	createTreeArray(&treeArray,NULL,arrayLength);
	for (i = 0; i < arrayLength; ++i)
	{
		// fprintf(stderr, "%s+++%d\n","Hello1",tempArray[i] );
	 	updateTreeArray(treeArray,tempArray[i],1);
	 	reversePairCount+=(i+1-getSumN(treeArray , tempArray[i]));//加上每个对应逆序对的数量
		// fprintf(stderr, "%s\n","Hello2" );
	}
	return reversePairCount;
}

main.c

#include <stdio.h>
#include <stdlib.h>
#include "treeArray.h"
#include "reversePair.h"


int main(int argc, char const *argv[])
{
	int array[]={9,1,0,5,4};
	printf("reversePair number is:%d\n",reverserPairNumber(array, sizeof(array)/sizeof(int)) );
	return 0;
}

makefile

<span style="font-size:18px;">main:treeArray.o main.o reversePair.o
	gcc treeArray.o main.o reversePair.o -o main.exe

treeArray.o:treeArray.h
main.o:treeArray.h reversePair.h
reversePair.o:reversePair.h

.PHONY:clean

clean:
	rm -f *.o *.exe</span>



qeesung
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
剑指Offer – 面试题51. 数组中的逆序对（归并排序，求逆序对）
01-20
1. 题目 在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。输入一个数组，求出这个数组中的逆序对的... 计算右侧小于当前元素的个数（二叉查找树&二分查找&归并排序逆序数总结） 方法
数组中的逆序对
jiangdongxiaobawang的博客
02-06 399
数组中的逆序对 1.题目描述 在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。输入一个数组,求出这个数组中的逆序对的总数P。并将P对1000000007取模的结果输出。 即输出P%1000000007 输入描述: 题目保证输入的数组中没有的相同的数字 数据范围： 对于%50的数据,size<=10^4 对于%75的数据,size<=10^5 对于%100...
逆序对
PUBG___的博客
12-29 645
逆序对指的是对于一个长度为N的序列，求不满足单调不下降且长度为2的子序列的个数。 首先，这个题是由冒泡排序发展出来的，答案也自然是冒泡排序交换次数，但是，那样一来，时间复杂度达到了n^2，所以，有一种较为快捷的算法。 这一个算法是由(nlogn)时间复杂度的归并排序完成的，利用的是分治思想，答案也利用了分治算法交换次数。 开始，我们设A为求逆序对数组，我们可以重新设置一个数组C，内容为对于每...
逆序对(归并排序做法)
萌新的博客
11-14 1321
逆序对什么是逆序对求逆序对个数思路举个栗子代码对于vetcor 什么是逆序对 对于一段序列aaa，如果ai>aja_i > a_jai​>aj​且i<ji < ji<j，那么aia_iai​和aja_jaj​就是一对逆序对，我们记作逆序对(ai,aj)(a_i,a_j)(ai​,aj​)。 求逆序对个数 我们先上一道例题 题目地址 题目就要求你得到一段序列的逆序对个数是多少 思路 举个栗子 比如对于序列5 4 2 6 3 1。我们用归并排序的思想可以得到一个左区间left
逆序对的归并求解
Renren151的博客
11-29 798
逆序对的归并求解什么是逆序对？如何求逆序对呢？方法一：暴力法方法二：归并算法归并排序算法归并算法求解逆序对问题分析问题解决代码实例扩展内容总结 什么是逆序对？ 数组中任意两个元素，凡是满足左边数字大于右边的,就构成一个逆序对。例如【5,9,3,6,8,10,1,4】 (10,1)就构成一个逆序对。 本文将介绍使用归并算法来求解逆序对的相关问题。 如何求逆序对呢？ 方法一：暴力法 最先想到的就是暴力法，双重for循环判断即可，这种方式就不在介绍了。 方法二：归并算法 求之前，我们先理解一下归并排序算法。一定要
算法：逆序对
Python极客
03-08 8580
逆序对 什么是逆序对呢？百度百科这样解释： 设 A 为一个有 n 个数字的有序集 (n>1)，其中所有数字各不相同。 如果存在正整数 i, j 使得 1 ≤ i < j ≤ n 而且 A[i] > A[j]，则 <A[i], A[j]> 这个有序对称为 A 的一个逆序对，也称作逆序数。 定义： 对于一个包含N个非负整数的数组A[1…n]，如果有i < j，且A[ i ]>A[ j ]，则称(A[ i] ,A[ j] )为数组A中的一个逆序对。 例如，数组（3
java面试题之数组中的逆序对
08-26
主要为大家详细介绍了java面试题之数组中的逆序对，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
逆序对（树状数组） C语言
01-03
广工《算法和高级数据结构教程》 逆序对（树状数组） c语言实现
java简单实现数组中的逆序对
08-26
主要为大家详细介绍了java简单实现数组中的逆序对，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
算法设计之分治思想（求数组的逆序对）
01-21
在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。输入一个数组，求出这个数组中的逆序对的总数。 示例 1: 输入: [7,5,6,4] 输出: 5 限制： 0 <= 数组长度 <= 50000 首先最...
关于逆序对的三种解法
weixin_30699465的博客
08-28 116
今天学习了逆序对，关于逆序对的三种解法做一个介绍，方便复习。 什么是逆序对？ 设 A 为一个有 n 个数字的有序集(n>1)，其中所有数字各不相同。 如果存在正整数 i, j 使得 1 ≤ i < j ≤ n 而且 A[i] > A[j]，则 <A[i], A[j]> 这个有序对称为 A 的一个逆序对。 逆序对的解法 第一种：冒泡法（暴力） ...
归并排序应用之逆序对
u014228447的博客
06-08 240
什么是逆序对？数组中任意两个元素组合是降序排列的，以下给出了暴力求解法和归并求解法。#include&lt;iostream&gt; using namespace std; #define N 12 //逆序对：其实就是求每个数右边有多少个数比其小 //暴力求解法 int VolentReversePair(int *a,int length) { int cnt=0; for(int i=...
浅谈逆序对
weixin_30485799的博客
07-01 372
目录 什么是逆序对 怎么求逆序对 1.暴力求解 2.归并排序 3.树状数组 朴素代码 优化版 插入求逆序对?!我也不知道应该叫什么 什么是逆序对 设 $A$ 为一个有...
逆序对的三种求法
q779的博客
09-05 2365
《 大 材 小 用 》
学习笔记——逆序对
banxikuan1546的博客
10-30 158
蒟蒻写文，难免出错，欢迎大佬来踩！ 逆序对的定义 其实逆序对是一个非常简单的概念。对于一个数组中的任何一个数，只要有一个在它后面的数小于它本身，那么这两个数字就构成了一个逆序对。我们举一个例子。 对于这样一个数组 A[4]={1,4,2,3}; 其中有两对逆序对，分别是（4，2）和（4，3）。 求逆序对个数的方式 有没有感...
学归并排序和逆序对，这篇文章就够了！！！归并排序和逆序对超详细整理！
林深不见鹿 的博客
07-02 3581
目录1.归并排序2.逆序对3.例题 1.归并排序 (1).介绍 归并排序是建立在归并操作上的一种有效的排序算法，该算法是采用分治法(DivideandConquer)的一个非常典型的应用。将已有序的子序列合并,得到完全有序的序列;即先使每个子序列有序,再使子序列段间有序。若将两个有序表合并成一个有序表,称为二路归并。 归并排序的时间复杂度是O(nlogn). 速度快,同时归并排序是稳定的排序,即相等的元素的顺序不会改变，如输人记录1(1) 3(2) 2(3) 2(4)5(5) (括号中是记录的关键字)时输出
对numpy数组进行逆序排序
最新发布
06-03
可以使用numpy中的sort方法，将数组进行排序，然后使用[::-1]将排序后的数组进行逆序，示例代码如下： ``` python import numpy as np ...其中，np.sort(arr)将数组arr进行排序，[::-1]表示对排序后的数组进行逆序。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值