【剑指offer】——以空间换时间练习

一、丑数

1、题目要求
我们把只包含因子2、3、5的数称作丑数，求按从小到大的顺序的第1500个丑数。例如，6、8都是丑数，但14不是，因为它包含因子7.习惯上我们把1当做第一个丑数。
2、题目分析
方法一：
首先，我们再来仔细分析一下丑数的概念，因为2,3，5是丑数的因子，那么就可以说明任意一个丑数对其中一个因子求余为0。丑数只能被2,3，5整除，也就是说，如果能被5整除，就除以连续5，如果最后得到的是1，那么这个数就是丑数。
因此，我们可以写出下面的函数来判断一个数是不是丑数

bool IsUgly(int number)
{
	while (number % 2 == 0)
		number /= 2;
	while (number % 3 == 0)
		number /= 3;
	while (number % 5 == 0)
		number /= 5;
	return(number == 1) ? true : false;
}
int GetUglyNumber(int index)
{
	if (index < 0)
		return 0;

	int number = 0;
	int uglyFound = 0;
	while (uglyFound < index)
	{
		++number;
		if (IsUgly(number))
		{
			++uglyFound;
		}
	}
	return number;
}

但是这种方法最大的问题就是每个整数都要计算，即使一个整数不是丑数，我们还是要对其进行除法和求余操作。因此这种算法的时间效率不是很高。

方法二：创建数组保存已经找到的丑数，用空间换时间的解法
基于上述算法的弊端，我们要找到一种只计算丑数的方法，而不在非丑数的整数上花费时间。我们可以创建一个数组，里面的数字是排好序的丑数。每个丑数都是前面的丑数乘以2、3或者5得到的。我们把已有最大的丑数记做M，接下来分析如何生成下一个丑数，该丑数肯定是前面某一个丑数乘以2、3或者5的结果，所以我们把已有的丑数乘以2得到M2，把已有的丑数乘以3得到M3，把已有的丑数乘以5得到M5。最后比较三个数的最小值。代码实现如下：

int MIN(int number1, int number2, int number3)
{
	int min = (number1 < number2) ? number1 : number2;
	min = (min < number3) ? min : number3;
	return min;
}
int GetUglyNumber(int index)
{
	if (index <= 0)
		return 0;

	int* pUglyNumber = new int[index];
	pUglyNumber[0] = 1;
	int nextUglyIndex = 1;

	int* pMultiply2 = pUglyNumber;
	int* pMultiply3 = pUglyNumber;
	int* pMultiply5 = pUglyNumber;

	while (nextUglyIndex < index)
	{
		int min = MIN(*pMultiply2 * 2, *pMultiply3 * 3, *pMultiply5 * 5);
		pUglyNumber[nextUglyIndex] = min;

		while (*pMultiply2 * 2 <= pUglyNumber[nextUglyIndex]);
		++pMultiply2;
		while (*pMultiply3 * 3 <= pUglyNumber[nextUglyIndex]);
		++pMultiply3;
		while (*pMultiply5 * 5 <= pUglyNumber[nextUglyIndex]);
		++pMultiply5;
		++nextUglyIndex;
	}
	int ugly = pUglyNumber[nextUglyIndex - 1];
	delete[] pUglyNumber;
	return ugly;
}

二、数组中的逆序对

1、题目要求
在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对，输入一个数组，求出这个数组中的逆序对的总数。例如：在数组{7,5，6,4}中，一共存在5个逆序对，分别是（7,6）、（7,5）、（7,4）、（6,4）和（5,4）。
2、题目分析
方法一：
对这道题最直观的解法可能就是顺序扫描整个数组，每扫描到一个数字，逐个比较该数字后面的数字的大小，求出这个数组中的逆序对。但是这种方法的效率不高，时间复杂度可达O(N^2)

方法二：一种以空间换时间的解法
具体的分析我们还是以数组{7,5，6，4}来进行分析。我们先考虑比较两个相邻的数字。总的概括来说就是一个先分解再组合的过程，类似于归并排序。如下图所示：

过程1和过程2就是一个不断分解的过程，当分解成只有一个元素的时候就要开始合并了，合并的过程是进行排序的合并，并且要统计其中的逆序对。
现在最关键的就是过程4合并、排序并统计逆序对的过程。这时，我们需要定义三个指针，p1,p2和p3，其中p1和p2分别指向两个数组的末尾,p3指向辅助数组的末尾。如下图a所示。每次比较两个指针指向的数字，如果p1指向的数字大于p2指向的数字，则构成了逆序对，并且逆序对的数目为第二个子数组中剩余数字的个数（本题中为2）。接下来把p1，p2所指的数字中较大的数字从后往前复制到下面的辅助数组中，然后对应的指针往前挪动一位，如面b图所示。然后再进行上述的比较过程，此时由于p1指向的数字小于p2所指向的数字，所以是不构成逆序对的，但是同样将p1，p2所指的数字中较大的数字从后往前复制到下面的辅助数组中，然后对应的指针往前挪动一位，如面c图所示

有了上述详细的讨论，我们就可以总结出统计逆序对的过程：先把数组分隔成子数组，统计出子数组内部的逆序对数目，然后再统计出两个相邻子数组之间的逆序对的数组。在统计逆序对的过程中，还需要对数组进行排序。所以写出代码实现如下：

int InversePairscore(int* data, int* copy, int start, int end)
{
	if (start = end)
	{
		copy[start] = data[start];
		return 0;
	}
	int length = (end - start) / 2;
	int left = InversePairscore(data, copy, start, start + length);
	int right = InversePairscore(data, copy, start + length, end);

	//i初始化为前半段的最后一个数字的下标
	int i = start + length;
	//jj初始化为后半段的最后一个数字的下标
	int j = end;
	int indexCopy = end;
	int count = 0;
	while (i >= start && j >= start + length + 1)
	{
		if (data[i] > data[j])
		{
			copy[indexCopy--] = data[i--];
			count += j - start- length;
		}
		else
		{
			copy[indexCopy--] = data[j--];
		}
	}
	for (; i >= start; i--)
		copy[indexCopy--] = data[i];
	for (; j >= start + length + 1; j--)
		copy[indexCopy--] = data[j];
	return count + left + right;
}
int InversePairs(int* data, int length)
{
	if (data == nullptr || length < 0)
		return 0;

	int* copy = new int[length];
	for (int i = 0; i < length; i++)
		copy[i] = data[i];

	int count = InversePairscore(data, copy,0,length-1);
	delete[] copy;
	return count;
}