中级算法之排序和搜索

总结：早某些问题的解决过程中，对问题中的数据进行排序之后会使问题变得简单，例如题目2，题目3，题目6，在涉及到排序的问题的时候，我认为还是不要轻易的自己去写排序函数，因为一来这样会比较耗费时间，二来自己选择的排序方法可能在面对不同数据量的排序时无法总是保持一个很高的效率，所以还是优先使用STL提供的sort函数。sort函数在数据量比较大的时候会采用快速排序,用递归来实现；在快排过程中一旦分段的数据量小于某个值就会采用插入排序；当递归次数比较多的时候还会使用堆函数；这样看来sort函数等于是综合了各种排序函数的优点。至于sort函数的具体用法可以参考博文《浅谈C++中qsort与sort的使用方法与区别》。至于搜索的问题，一类就是按照某种规律去寻找目标值，例如题目4，题目8；还有一类就是对二分查找的应用，例如题目5，题目7。二分查找一般用来解决“在有序数组中对某些特定值的查找”问题，特别是一些查找问题中明确表示时间复杂度中含有logn，这时候要考虑到二分查找这种方法。在二分查找的问题中，一种问题是在二分的过程中直接判断中间元素是否为目标值，即在过程中就得到答案；另一种则是无法在过程中判断，需要不断的缩小答案所在范围，直到左右指针重合才是答案。这两种问题的具体差别可以通过题目《寻找旋转排序数组中的最小值》来理解。二分查找的基本概念可以看《数值计算处理之二分法》，二分查找的一些变形问题可以看《七种二分查找变形情况合集，核心思想不变!》。

题目1：颜色分类

给定一个包含红色、白色和蓝色，一共 n 个元素的数组，原地对它们进行排序，使得相同颜色的元素相邻，并按照红色、白色、蓝色顺序排列。

此题中，我们使用整数 0、 1 和 2 分别表示红色、白色和蓝色。

注意:
不能使用代码库中的排序函数来解决这道题。

示例:

输入: [2,0,2,1,1,0]
输出: [0,0,1,1,2,2]

思路:先遍历一遍数组，记录三种数字出现次数，之后按照顺序和所记录的个数为原数组重新赋值即可。

void sortColors(vector<int>& nums) 
{
	int len = nums.size();
	if(len==0)
		return;
	map<int,int> count;
	for(int i=0;i<len;i++)
		count[nums[i]]++;
	int index = 0;
	for(int i=0;i<3;i++)
	{
		for(int j=0;j<count[i];j++)
			nums[index++] = i;		
	} 
}

题目2：前 K 个高频元素

给定一个非空的整数数组，返回其中出现频率前 k 高的元素。

示例 1:

输入: nums = [1,1,1,2,2,3], k = 2
输出: [1,2]
示例 2:

输入: nums = [1], k = 1
输出: [1]

思路:先遍历一遍数组，记录各数字出现次数，之后按照出现次数进行排序，取出前k个数。

static bool cmp(const vector<int> &a,const vector<int> &b) 
{ 
	return a[1]>b[1]; 
}
vector<int> topKFrequent(vector<int>& nums, int k) 
{
	int len = nums.size();
	vector<int> res; 
	//记录每个数字出现次数 
	map<int,int> Map;
	for(int i=0;i<len;i++)
		Map[nums[i]]++;
	vector<vector<int>> count;
	//为了能排序要将map导入vector中 
	for(auto iter=Map.begin();iter!=Map.end();iter++) 
	{
		vector<int> temp;
		temp.push_back(iter->first);
		temp.push_back(iter->second);
		count.push_back(temp);
	}
	sort(count.begin(),count.end(),cmp);
	for(int i=0;i<k;i++)
		res.push_back(count[i][0]);
	return res;    
}

题目3：数组中的第K个最大元素

在未排序的数组中找到第 k 个最大的元素。请注意，你需要找的是数组排序后的第 k 个最大的元素，而不是第 k 个不同的元素。

示例 1:

输入: [3,2,1,5,6,4] 和 k = 2
输出: 5
示例 2:

输入: [3,2,3,1,2,4,5,5,6] 和 k = 4
输出: 4

思路:排序数组，返回从后往前数第k个数。

int findKthLargest(vector<int>& nums, int k) 
{
	sort(nums.begin(),nums.end());
	int len = nums.size();
	return nums[len-k];    
}

题目4：寻找峰值

峰值元素是指其值大于左右相邻值的元素。

给定一个输入数组 nums，其中 nums[i] ≠ nums[i+1]，找到峰值元素并返回其索引。

数组可能包含多个峰值，在这种情况下，返回任何一个峰值所在位置即可。

你可以假设 nums[-1] = nums[n] = -∞。

示例 1:

输入: nums = [1,2,3,1]
输出: 2
解释: 3 是峰值元素，你的函数应该返回其索引 2。

示例 2:

输入: nums = [1,2,1,3,5,6,4]
输出: 1 或 5 
解释: 你的函数可以返回索引 1，其峰值元素为 2；
         或者返回索引 5， 其峰值元素为 6。

思路:遍历数组寻找第一个左右元素都比其小的元素，但是要特别注意第一个和最后一个元素。

int findPeakElement(vector<int>& nums) 
{
	int len = nums.size();
	if(len==1)
		return 0;
	for(int i=0;i<len;i++)
	{
		if(i==0)
		{
			if(nums[i]>nums[i+1])
				return i;
			continue;
		}	
		else if(i==len-1)
		{
			if(nums[i]>nums[i-1])
				return i;
			continue;
		}
		else if(nums[i]>nums[i-1]&&nums[i]>nums[i+1])
			return i;
	}    
	return -1;
}

题目5：在排序数组中查找元素的第一个和最后一个位置

给定一个按照升序排列的整数数组 nums，和一个目标值 target。找出给定目标值在数组中的开始位置和结束位置。

你的算法时间复杂度必须是 O(log n) 级别。

如果数组中不存在目标值，返回 [-1, -1]。

示例 1:

输入: nums = [5,7,7,8,8,10], target = 8
输出: [3,4]
示例 2:

输入: nums = [5,7,7,8,8,10], target = 6
输出: [-1,-1]

思路:先通过二分查找找到目标节点的位置i，如果要找到第一次出现的位置，那么就继续用二分查找搜寻i之前的范围，即[l,i)；如果要找到最后一次出现的位置，那么就继续用二分查找搜寻i之后的范围，即(i,r]。

vector<int> searchRange(vector<int>& nums,int target) 
{
	 int len = nums.size();
	 int a[2] = {-1,-1};
	 vector<int> res;
	 res.assign(a,a+2);
	 if(len==0)
	 	return res;
	 int l = 0,r = len-1; 
	 //找第一个位置
	 while(l<=r)
	 {
		int m = l+(r-l)/2;
		if(nums[m]==target)
		{
			if(res[0]==-1)
				res[0] = m;
			else
			 	res[0] = min(res[0],m);
			r = m-1;
		}
	 	else if(nums[m]<target)
	 		l = m+1;
	 	else if(nums[m]>target)
	 		r = m-1;
	 } 
	 //找最后一个位置 
	 l = 0;
	 r = len-1; 
	 while(l<=r)
	 {
		int m = l+(r-l)/2;
		if(nums[m]==target)
		{
			if(res[1]==-1)
				res[1] = m;
			else
			 	res[1] = max(res[1],m);
			l = m+1;
		}
	 	else if(nums[m]<target)
	 		l = m+1;
	 	else if(nums[m]>target)
	 		r = m-1;
	 }
	 return res;   
}

题目6：合并区间

给出一个区间的集合，请合并所有重叠的区间。

示例 1:

输入: [[1,3],[2,6],[8,10],[15,18]]
输出: [[1,6],[8,10],[15,18]]
解释: 区间 [1,3] 和 [2,6] 重叠, 将它们合并为 [1,6].
示例 2:

输入: [[1,4],[4,5]]
输出: [[1,5]]
解释: 区间 [1,4] 和 [4,5] 可被视为重叠区间。

思路:先将范围数组按范围起始值升序排序，将起始值相同的按范围结束值降序排列。这样一来相同起始值的范围不需要进行判断，最先出现的那个范围就是有该起始值的所有范围的最大范围。之后判断不同起始值之间的范围，如果第i个范围的结束值大于等于第j个范围的起始值，且小于第j个范围的结束值那么此时合并两范围，合并后的范围为i的起始值到j的结束值。重复上述过程直到所有范围都被遍历完。

//将范围数组按起始值升序排序，将起始值相同范围的按结束值降序排列 
static bool cmp(const vector<int> &a,const vector<int> &b) 
{ 
	if(a[0]==b[0])
		return a[1]>b[1];
	else 
		return a[0]<b[0]; 
}
vector<vector<int>> merge(vector<vector<int>>& intervals) 
{
	int len = intervals.size();
	if(len<=1)
		return intervals;
	vector<vector<int>> res;
	sort(intervals.begin(),intervals.end(),cmp);
	//指向每次合并的起始范围 
	int point = 0;
	int i = 0; 
	//合并过程 
	while(point<len)
	{
		vector<int> range = intervals[point];
		for(i=point+1;i<len;i++)
		{
			vector<int> temp = intervals[i];
			if(range[0]==temp[0])
				continue;
			if(range[1]>=temp[0])
			{
				if(range[1]<temp[1])
					range[1] = temp[1];
			}
			else
				break;
		}
		point = i;
		res.push_back(range);
	}
	return res;
}

题目7：搜索旋转排序数组

假设按照升序排序的数组在预先未知的某个点上进行了旋转。

( 例如，数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2] )。

搜索一个给定的目标值，如果数组中存在这个目标值，则返回它的索引，否则返回 -1 。

你可以假设数组中不存在重复的元素。

你的算法时间复杂度必须是 O(log n) 级别。

示例 1:

输入: nums = [4,5,6,7,0,1,2], target = 0
输出: 4
示例 2:

输入: nums = [4,5,6,7,0,1,2], target = 3
输出: -1

思路:先用二分查找找到分界点，即数组中的最小值(具体思路可以看"寻找旋转排序数组中的最小值")，之后判断目标值是在前半段还是在后半段，最后在相应范围内使用二分查找搜索目标值。

//二分查找 
int binarySearch(vector<int> &nums,int left,int right,int target)
{
	if(left>right)
		return -1;
	int mid = (left+right)/2;
	if(nums[mid]==target)
		return mid;  
	if(nums[mid]>target)
		return binarySearch(nums,left,mid-1,target);
	else
		return binarySearch(nums,mid+1,right,target);
}

//使用二分查找寻找最小值 
int search(vector<int> &nums,int target) 
{
	int len = nums.size();
	if(len==0)
		return -1;
	//找到翻转的分界点,l指向最小值 
	int l = 0,r = len-1;
	while(l<r)
	{
		int m = l+(r-l)/2;
		if(nums[m]>nums[r])
			l = m+1;
		else
			r = m;
	}
	//如果数组本身没有翻转，要重新确定二分查找的范围 
	if(l==0)
		l = len; 
	if(target>=nums[0]&&target<=nums[l-1])
		return binarySearch(nums,0,l-1,target);
	else
		return binarySearch(nums,l,len-1,target);	    
}

题目8：搜索二维矩阵 II

编写一个高效的算法来搜索 m x n 矩阵 matrix 中的一个目标值 target。该矩阵具有以下特性：

每行的元素从左到右升序排列。
每列的元素从上到下升序排列。

示例:

现有矩阵 matrix 如下：

[
  [1,   4,  7, 11, 15],
  [2,   5,  8, 12, 19],
  [3,   6,  9, 16, 22],
  [10, 13, 14, 17, 24],
  [18, 21, 23, 26, 30]
]
给定 target = 5，返回 true。

给定 target = 20，返回 false。

思路:这个题关键是要看到左下角和右上角这两个点的特殊性，以左下角为例，向上走数变小，向右走数变大，如果目标数大于该点就往左搜索，如果目标数小与该点就往上搜索，直到搜索到目标数或者超出矩阵范围。 

bool searchMatrix(vector<vector<int>> &matrix, int target) 
{
	int width = matrix.size();
	if(width==0)
		return false;
	int length = matrix[0].size();
	if(length==0)
		return false;
	//从左下角的节点开始搜索 
	int x = width-1;
	int y = 0;
	while(x>=0&&y<length)
	{
		if(matrix[x][y]==target)
			return true;
		if(matrix[x][y]>target)
			x--;		
		else 
			y++;
	}     
	return false;   
}