一、寻找右区间(二分法)
题意：题目很容易理解 但是转换为二分法有点晦涩
给你一个区间数组 intervals ，其中 intervals[i] = [starti, endi] ，且每个 starti 都 不同 。区间 i 的 右侧区间 可以记作区间 j ，并满足 startj`` >= endi ，且 startj 最小化 。注意 i 可能等于 j 。
让我们去找一个区间的最小右侧区间，满足条件：右侧区间的start值>该区间的end值，可能存在多个右侧区间，取最小的start值的区间。并把该区间的下标放到数组里面返回。没有记作-
思路：
题目要让我们去找一个区间的最小右侧区间。如何做到最小？
1.首先将每个区间的start值进行排序
2.然后for循环遍历每一个区间，将其end值作为target。
3.然后二分查找第一个>=target的start值的下标。放到res数组中
4.返回res数组
代码：
//将每一个区间的左端点排序 遍历每一个数组的右端点 找到第一个比它大的左端点 然后加入到集合中。如何将左端点排序，使用二维数组
class Solution {
public int[] findRightInterval(int[][] intervals) {
//第一步 创建sortStart数组 并且排序
int[][] sortStart=new int[intervals.length][2];//start值：下标
for(int i=0;i<intervals.length;i++){
sortStart[i]=new int[]{intervals[i][0],i};
}
Arrays.sort(sortStart,(a,b)->a[0]-b[0]);
//第二步 遍历每一个区间的end 并且将其作为target
int[] res=new int[intervals.length];
for(int i=0;i<intervals.length;i++){
int target=intervals[i][1];//第i个区间的end值
int left=0,right=sortStart.length-1;
//第三步 二分查找最小的>=end的start值的下标 放入res数组中
while(left<right){
int mid=left+(right-left)/2;
if(sortStart[mid][0]>=target){
right=mid;
}else{
left=mid+1;
}
}
res[i]=sortStart[left][0]>=intervals[i][1]?sortStart[left][1]:-1;
}
return res;
}
}
二、最长递增子序列（dp+二分法）
解法一：dp动态规划
dp五部曲：
1.dp[i]的含义:以i为结尾的最长递增子序列的长度
2.递推公式：dp[i]=Math.max(dp[i],dp[j]+1);在0->i，如果找到比nums[i]小的数，说明找到了一个递增序列，然后对dp[i]进行更新。
3.初始化dp[i]=1;
4.遍历的顺序:双层for循环，i从1开始，j从0开始直j<i;
代码：
class Solution {
public int lengthOfLIS(int[] nums) {
//1.dp[i]:以i结尾的最长递增子序列的长度
int[] dp=new int[nums.length];
Arrays.fill(dp,1);
int max=1;
for(int i=1;i<nums.length;i++){
for(int j=0;j<i;j++){
if(nums[j]<nums[i]){
dp[i]=Math.max(dp[i],dp[j]+1);
}
}
max=Math.max(max,dp[i]);
}
return max;
}
}
解法二：辅助数组+二分法
思路：
遍历数组，如果遇到的数字是大于尾部元素的，直接放到尾部元素后面，使得递增序列变大；
如果遇到的数字是小于尾部元素的，为了使递增的速度最慢，就要将该元素放到最合适的地方.
那么这个最合适的地方如何去寻找？ 当然我们可以利用辅助数组单调递增的规律，使用二分查找法去寻找最合适的地方。
代码:
class Solution {
public int lengthOfLIS(int[] nums) {
//1.定义辅助数组
int[] sortNums=new int[nums.length];
int size=1;
sortNums[0]=nums[0];
for(int i=0;i<nums.length;i++){
//如果大于的话 直接放到sortNums的后边
if(nums[i]>sortNums[size-1]){
sortNums[size++]=nums[i];
}else{
//如果小于的话 我们就要去找合适的位置
int target=nums[i];
int left=0,right=size-1;
while(left<=right){
int mid=left+(right-left)/2;
if(sortNums[mid]>=target){
right=mid-1;
}else{
left=mid+1;
}
}
sortNums[right+1]=nums[i];
}
}
return size;
}
}
三、寻找峰值
峰值元素是指其值严格大于左右相邻值的元素。
给你一个整数数组 nums，找到峰值元素并返回其索引。数组可能包含多个峰值，在这种情况下，返回 任何一个峰值 所在位置即可。你可以假设 nums[-1] = nums[n] = -∞ 。
因为nums[-1]=nums[n]=-∞；因此可以推断出:
nums[i]<nums[i+1]:那么后面一定存在一个峰值；
nums[i]>=nums[i+1];那么前面一定存在一个峰值；
思路：
那么就根据推断出的规律来进行二分查找：如果nums[mid]>=nums[mid+1] left=mid+1;
nums[mid]<nums[mid+1] right=mid;
代码：
class Solution {
public int findPeakElement(int[] nums) {
if(nums.length==1)return 0;
int left=0,right=nums.length-1;
while(left<right){
int mid=left+(right-left)/2;
if(nums[mid]>=nums[mid+1]){
right=mid;
}else{
left=mid+1;
}
}
return left;
}
}
四、找到k个最接近的元素
题意：
给定一个 排序好 的数组 arr ，两个整数 k 和 x ，从数组中找到最靠近 x（两数之差最小）的 k 个数。返回的结果必须要是按升序排好的。
输入：arr = [1,2,3,4,5], x = 3, k = 4
输出：[1,2,3,4] 相同距离的话 加入较小的解法一：双指针删除法
思路：
逆向思维，在数组中删除(size-k)个离x最远的数字。可以使用双指针（left，right）向x靠近的同时不断删除元素。
比如在1 2 3 4 5中寻找4个最靠近3的数。
left指向1,right指向5。和3的距离都为2，将5删除。剩余四个数字 4==k。那么加入到集合中返回。
代码：
class Solution {
public List<Integer> findClosestElements(int[] arr, int k, int x) {
// 双指针删除法
List<Integer> res = new ArrayList<>();
int number = arr.length;
int left = 0;
int right = number - 1;
int count = 0;
while (left <= right) {
if (count == number - k) {
for (int i = left; i <= right; i++) {
res.add(arr[i]);
}
}
int diff1 = Math.abs(x - arr[left]);
int diff2 = Math.abs(arr[right] - x);
if (diff1 <= diff2)
right--;
else
left++;
count++;// 已经删除的数字
}
return res;
}
}
五、俄罗斯套娃问题(最长上升子序列的二维版)
你一个二维整数数组 envelopes ，其中 envelopes[i] = [wi, hi] ，表示第 i 个信封的宽度和高度。当另一个信封的宽度和高度都比这个信封大的时候，这个信封就可以放进另一个信封里，如同俄罗斯套娃一样。
解法一：动态规划(超时)
解法二：贪心+二分查找
思路：
当只有宽和高都比上一个信封大的时候，才能实现套娃。
我们可以先对宽度进行升序排列，确认了宽度之后，就变成一维的求最长上升子序列了。
如何求最大长度的高度序列 。使用贪心 算法:每次我们都希望放在末尾的值是一个符合条件并且尽可能小的数字，这样我们的长度最长的概率就最大 。(因此当我们遇到heights[i]<tails[size]的时候，我们需要将heights[i]放到合适的位置，但是heights所对应宽度是可能相等的 。在相等的时候，我们应该按照降序排列，这样在更新下一个的时候就会把它刷掉)。
举个例子理解一下：假如按照升序排列后为:(5,5),(6,6),(7,2)(7,1)(8,3),(9,4)。
1.envelopes[i][1]=5, 集合为空，tails[0]=5 size=1;
2.envelopes[i][1]=6, 6大于5，tails[1]=6,size=2;
3.envelopes[i][1]=2, 2小于6，给2寻找合适的位置,2<5。因此tails[0]=2;
4.envelopes[i][1]=1, 1小于6，给1寻找合适的位置,1<2,因此tails[0]=1;
5.envelopes[i][1]=3，3小于6，给3寻找合适的位置,3<6,因此tails[1]=3；
6.envelopes[i][1]=4，4大于3，因此tails[2]=4；size=3
寻找合适的位置是根据二分搜索法进行寻找。
代码：
class Solution {
public int maxEnvelopes(int[][] envelopes) {
if(envelopes.length==0)return 0;;
// 对信封的宽度排序
Arrays.sort(envelopes,new Comparator<int[]>(){
public int compare(int[] a,int[] b){
return a[0]==b[0]?b[1]-a[1]:a[0]-b[0];
}
});
int maxSize=1;
int size=1;
int[] tails=new int[envelopes.length];
tails[0]=envelopes[0][1];
for(int i=1;i<envelopes.length;i++){
if(envelopes[i][1]>tails[size-1]){
tails[size++]=envelopes[i][1];
}else{
int left=0,right=size-1;
int target=envelopes[i][1];
while(left<=right){
int mid=left+(right-left)/2;
if(tails[mid]>=target)right=mid-1;
else left=mid+1;
}
tails[right+1]=target;
}
}
return size;
}
}
六、寻找旋转排序数组中的最小值(要求时间复杂度为O(logN))
思路：二分法
旋转之前，是一个升序数组；旋转之后，会变成两段升序数组。
旋转时，小数往后走，大数旋转到前面来。分情况：
1.起始点在到达中间之前 ，(右边部分一定处于升序),nums[mid]的值一定是小于nums[right]的，此时起始点一定在mid左边(包括mid)
2.起始点到达中间之后 ，大数占领起始点之前的区域,nums[mid]的值一定是大于nums[right]的，此时起始点一定是在右半部分的。(反证一下，如果起始点在左部分的话，那么起始点的右边一定是升序的，那么nums[mid]一定小于nums[right])
所以
1.当nums[mid]>nums[right]，起始点一定在右边,更新左边界left=mid+1;
2.当nums[mid]<=nums[right],起始点一定在左边，更新有边界right=mid;
代码：
class Solution {
public int findMin(int[] nums) {
int size=nums.length;
int left=0,right=size-1;
while(left<right){
int mid=left+(right-left)/2;
if(nums[mid]<nums[right]){
right=mid;
}else{
left=mid+1;
}
}
return nums[left];
}
}
七、搜索旋转排序数组
在传递给函数之前，nums 在预先未知的某个下标 k（0 <= k < nums.length）上进行了 旋转 ，使数组变为 [nums[k], nums[k+1], ..., nums[n-1], nums[0], nums[1], ..., nums[k-1]]（下标 从 0 开始 计数）。例如， [0,1,2,4,5,6,7] 在下标 3 处经旋转后可能变为 [4,5,6,7,0,1,2] 。
给你 旋转后 的数组 nums 和一个整数 target ，如果 nums 中存在这个目标值 target ，则返回它的下标，否则返回 -1 。
思路：
将一个排序好的数组旋转，变成两段升序序列(也可能是一段 就是原始的)。然后找到元素的起始点。两种情况：
1.如果起始点==0，说明并没有进行旋转，还是原始的数组。
2.如果起始点>0,说明进行了旋转，在两段序列中进行查找target就可以。
代码:
class Solution {
public int search(int[] nums, int target) {
if (nums.length == 1 && nums[0] == target)
return 0;
// 首先找到起始点 找到起始点之后 两段升序找target
int left = 0, right = nums.length - 1;
while (left < right) {
int mid = left + (right - left) / 2;
if (nums[mid] <= nums[right]) {
// 说明mid一定在左半边
right = mid;
} else {
left = mid + 1;
}
}
// left就是起始的位置
int res1 = 0;
int res2 = 0;
if (left == 0)
return binarySearch(nums, 0, nums.length - 1, target);
else {
res1 = binarySearch(nums, 0, left - 1, target);
res2 = binarySearch(nums, left, nums.length - 1, target);
}
return res1 == -1 ? res2 : res1;
}
public int binarySearch(int[] nums, int left, int right, int target) {
int index = -1;
while (left < right) {
int mid = left + (right - left) / 2;
if (nums[mid] > target) {
right = mid;
} else if (nums[mid] < target) {
left = mid + 1;
} else {
return mid;
}
}
return nums[left]==target?left:index;
}
}
八、搜索二维矩阵II
编写一个高效的算法来搜索 m xn 矩阵 matrix 中的一个目标值 target 。该矩阵具有以下特性：
- 每行的元素从左到右升序排列。
- 每列的元素从上到下升序排列。
思路：
如果从左上角或者右下角开始寻找的话，不具有区别度。
如果从右上角或者左下角寻找的话：
1.右上角：左边变小，下边变大
2.左下角：上边变小，右边变大
代码：
class Solution {
public boolean searchMatrix(int[][] matrix, int target) {
//从右上角出发
int rol=matrix.length;
int cow=matrix[0].length;
int x=0,y=cow-1;
while(x<rol&&y>=0){
if(matrix[x][y]<target){
x++;
}else if(matrix[x][y]>target){
y--;
}else{
return true;
}
}
return false;
}
}