剑指offer数组中的查重

1.在一个长度为n的数组中，所有数组都在0到n-1，然而有些数子是重复的，但不知道有几个数字重复，也不知道每个数字重复了几次，请找出任意一个重复的数字，例如：如果输入长度为7的数组｛2，3，1，0，2，5，3｝ 那么重复的数字就是2或者3；

**思路一：**排个序，那么相同的元素肯定在一起。之后前后比较就可以了。

void Qsort(vector<int>& arr, int left, int right)
{
	if (left > right)
		return;
	int i, j;
	i = left;
	j = right;
	while (i<j)
	{
		while (arr[left]<=arr[j] && i<j)
		{
			j--;
		}
		while (arr[left]>=arr[i] && i<j)
		{
			i++;
		}
		if(i<j)
		swap(arr[i], arr[j]);
	}
	swap(arr[left], arr[j]);
	Qsort(arr,left,i-1);
	Qsort(arr, i + 1, right);

}

//异常情况 1.数组为空，数组中的元素不在0到size-1的区间内
//直接排序然后找相邻的
bool Duplicate(vector<int>arr, int*Duplication)
{
	if (arr.empty())
		return false;
	Qsort(arr, 0, arr.size() - 1);
	 *Duplication =arr[0];
	for (int i=1; i < arr.size(); i++)
	{
		if (arr[i] == *Duplication)
			return true;
		else
		{
			*Duplication = arr[i];
		}
	}
	return false;
}

上半部分用快速排序实现，然后找出前后相同的，如果代码中存在多个相同的那么只要把代码稍加修改就可以找出所有的相同元素。

时间复杂度分析：快速排序为 O(nlong2 n)，而后面的查找为O(N); 而且之后只是扫了一遍，最后的时间复杂度为 O（nlong2 n）
空间复杂度： O（1） 没有开辟额外的空间

思路二：利用桶排序的思想，计数+1之后找相似的就行

bool DuplicateBucket(const vector<int>& arr,int* ret)
{
	if (arr.empty())
		return false;
	int* ar = (int*) calloc(arr.size(),4);
	if(ar==nullptr)  //空间申请失败
	return false;
	for (int i = 0; i < arr.size() - 1; i++)
	{
		ar[arr[i]]++;
		if (ar[arr[i]] == 2)
		{    //找到后直接返回提高运行效率
			*ret = arr[i];
			return true;
		}
	}
	return false;
}

时间复杂度：O（N）桶在++的时候还是需要扫一遍
空间复杂度：O（N）

思路三 因为这个数组大小和元素的范围是匹配的，我们可以重排这个数组，当扫描到下标为i的数字时，首先比较这个数字m是不是等于i，如果等于找下一个；如果不等于就把它和第m个元素交换，之后在进行上面的步骤，如果归为就找下一个。

bool Duplicate(int* arr, int size, int* duplication)
{
	if (nullptr == arr || size < 0)
		return false;
	for (int i = 0; i < size; i++)
	{
		if (arr[i] < 0||arr[i]>size-1)
			return false;	
	}
	for (int i = 0; i < size; i++)
	{
		while (arr[i] != i)
		{
			if (arr[i] == arr[arr[i]])
			{
				*duplication = arr[i];
				return true;
			}
			swap(arr[i], arr[arr[i]]);
		}
	}
	return false;

}

时间复杂度：因为一次交换了两个，每进行一次交换那么就会有一个数字回到自己应该在的位置，所以时间复杂度为O（N）
空间复杂度：O（1）