17、BM17 二分查找-I

思路步骤：

• step 1：从数组首尾开始，每次取中点值。
• step 2：如果中间值等于目标即找到了，可返回下标，如果中点值大于目标，说明中点以后的都大于目标，因此目标在中点左半区间，如果中点值小于目标，则相反。
• step 3：根据比较进入对应的区间，直到区间左右端相遇，意味着没有找到。

public class Solution {/*** 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可** * @param nums int整型一维数组 * @param target int整型 * @return int整型*/public int search (int[] nums, int target) {// 二分查找int l = 0;int r = nums.length - 1;//从数组首尾开始，直到二者相遇while(l <= r){//每次检查中点的值int m = (l + r) / 2;if(nums[m] == target){return m;}//进入左的区间if(nums[m] > target){r = m - 1;}else{l = m + 1;}}//未找到return -1;}
}

18、BM18 二维数组中的查找

思路步骤：

似乎我们可以直接从上到下遍历矩阵，再从左到右遍历矩阵每一行，然后检验目标值是否是遇到的元素。

//两层循环，遍历二维数组
for(int i = 0; i < n; i++)  for(int j = 0; j < m; j++)//找到targetif(array[i][j] == target)  return true;

但是我们这样就没有利用到矩阵内部的行列都是有序这个性质，我们再来找找规律：

首先看四个角，左上与右下必定为最小值与最大值，而左下与右上就有规律了：左下元素大于它上方的元素，小于它右方的元素，右上元素与之相反。既然左下角元素有这么一种规律，相当于将要查找的部分分成了一个大区间和小区间，每次与左下角元素比较，我们就知道目标值应该在哪部分中，于是可以利用分治思维来做。

具体做法：

• step 1：首先获取矩阵的两个边长，判断特殊情况。
• step 2：首先以左下角为起点，若是它小于目标元素，则往右移动去找大的，若是他大于目标元素，则往上移动去找小的。
• step 3：若是移动到了矩阵边界也没找到，说明矩阵中不存在目标值。

图示：

public class Solution {public boolean Find (int target, int[][] array) {// 二分查找//basecase//首先判断矩阵的两个边长if(array.length == 0){return false;}if(array[0].length == 0){return false;}//定义两个变量int m = array.length;int n = array[0].length;//从最左下角开始往右或者往上找for(int i = 0, j = n -1; i < m && j >= 0;){//小于目标值，开始往右找if(array[i][j] < target){i++;}else if(array[i][j] > target){j--;}else{return true;}}return false;  }
}

19、BM19 寻找峰值

思路：

因为题目将数组边界看成最小值，有两种情况：

1. 往下坡方向走，有可能遇到新的山峰，也有可能一路走到深渊谷底；
2. 往上坡方向走，由于最后面是深渊，所以一定能找到山峰；

而我们只需要找到其中一个波峰，

因此只要不断地往高处走，一定会有波峰。

那我们可以每次找一个标杆元素，将数组分成两个区间，每次就较高的一边走

因此也可以用分治来解决，而标杆元素可以选择区间中点。

具体做法：

• step 1：二分查找首先从数组首尾开始，每次取中间值，直到首尾相遇。
• step 2：如果中间值的元素大于它右边的元素，说明往右是向下，我们不一定会遇到波峰，但是那就往左收缩区间。
• step 3：如果中间值大于右边的元素，说明此时往右是向上，向上一定能有波峰，那我们往右收缩区间。
• step 4：最后区间收尾相遇的点一定就是波峰。

图示：

public class Solution {public int findPeakElement (int[] nums) {//关键思想：下坡的时候可能找到波峰，但是可能找不到，一直向下走的//上坡的时候一定能找到波峰，因为题目给出的是nums[-1] = nums[n] = -∞int l = 0;int r = nums.length - 1;while(l < r){//int mid = l + ((l - r)>>1);int mid = (l + r) / 2;//右边是往下，不一定有波峰,就往左边找if(nums[mid] > nums[mid + 1]){r = mid;}else{//右边是往上，一定有波峰l = mid + 1;}   }return r; }
}

20、BM20 数组中的逆序对

思路步骤

那么，我们先来说说归并算法吧，归并算法讲究一个先分后并！

先分：分呢，就是将数组分为两个子数组，两个子数组分为四个子数组，依次向下分，直到数组不能再分为止！

后并：并呢，就是从最小的数组按照顺序合并，从小到大或从大到小，依次向上合并，最后得到合并完的顺序数组！

介绍完归并排序，我们来说说归并统计法，我们要在哪个步骤去进行统计呢？

归并统计法，关键点在于合并环节，在合并数组的时候，当发现右边的小于左边的时候，此时可以直接求出当前产生的逆序对的个数。

举个例子：

在合并 {4 ,5} {1 , 2} 的时候，首先我们判断 1 < 4，我们即可统计出逆序对为2，为什么呢？这利用了数组的部分有序性。因为我们知道 {4 ,5} 这个数组必然是有序的，因为是合并上来的。此时当 1比4小的时候，证明4以后的数也都比1大，此时就构成了从4开始到 {4,5}这个数组结束，这么多个逆序对（2个），此时利用一个临时数组，将1存放起来，接着比较2和4的大小，同样可以得到有2个逆序对，于是将2也放进临时数组中，此时右边数组已经完全没有元素了，则将左边剩余的元素全部放进临时元素中，最后将临时数组中的元素放进原数组对应的位置。

最后接着向上合并~

可以看到下面这张图~

public class Solution {int count = 0;public int InversePairs (int[] nums) {// 归并排序//长度小于2则无逆序对if (nums == null || nums.length < 2) {return 0;}//将数组分为左右两部分进行排序mergeSort(nums, 0, nums.length - 1);return count;}private void mergeSort(int[] arr, int L, int R) {//basecase//如果L下标和R下标重合，那也说明有序if (L == R) {return;}//找分割点int mid = L + ((R - L) >> 1);//将 左边部分排好序mergeSort(arr, L, mid);//将 右边部分排好序mergeSort(arr, mid + 1, R);//merge，将两部分排好序的数组进行整体排序merge(arr, L, mid, R);}public void merge(int[] arr, int L, int mid, int R) {//首先定义一个help数组,长度为此时两个子数组加起来的长度int[] help = new int[R - L + 1];//临时数组的下标起点int i = 0;//定义两个指针int p1 = L;int p2 = mid + 1;//如果这两个数组都没有越界while (p1 <= mid && p2 <= R) {// 当左子数组的当前元素小的时候，跳过，无逆序对if (arr[p1] <= arr[p2]) {// 放入临时数组help[i++] = arr[p1++];} else { // 否则，此时存在逆序对// 放入临时数组help[i++] = arr[p2++];// 逆序对的个数为    左子数组的终点- 当前左子数组的当前指针count += mid - p1 + 1;count %= 1000000007;}//help[i++] = arr[p1] < arr[p2] ? arr[p1++] : arr[p2++];}//如果左边的数组没有越界while (p1 <= mid) {//将左边数组的值直接拷贝到hele数组里面help[i++] = arr[p1++];}//如果右边的数组没有越界while (p2 <= R) {//将右边数组的值直接拷贝到hele数组里面help[i++] = arr[p2++];}//经过上面的步骤，help数组有序啦，拷贝到arr数组就完成啦for (i = 0; i < help.length; i++) {arr[L + i] = help[i];}}
}

21、BM21 旋转数组的最小数字

解题思路：

排序数组的查找问题首先考虑使用 二分法 解决，其可将 遍历法 的 线性级别 时间复杂度降低至 对数级别

算法流程：

1. 初始化： 声明 i, j 双指针分别指向 array 数组左右两端

2. 循环二分： 设 m = (i + j) / 2 为每次二分的中点（ “/” 代表向下取整除法，因此恒有 i≤m1、当 array[m] > array[j] 时： m 一定在 左排序数组 中，即旋转点 x 一定在 [m + 1, j] 闭区间内，因此执行 i = m + 1

3. 当 array[m] < array[j] 时： m 一定在 右排序数组 中，即旋转点 x 一定在[i, m]闭区间内，因此执行 j = m

4. 当 array[m] = array[j] 时： 无法判断 mm 在哪个排序数组中，即无法判断旋转点 x 在 [i, m] 还是 [m + 1, j] 区间中。

   解决方案： 执行 j = j - 1 缩小判断范围

5. 返回值： 当 i = j 时跳出二分循环，并返回 旋转点的值 array[i] 即可。

public class Solution {/*** 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可** * @param nums int整型一维数组 * @return int整型*/public int minNumberInRotateArray (int[] nums) {// basecaseif(nums.length == 0){return 0;}//左右指针int l = 0 , r = nums.length - 1;//循环while(l < r){//找到数组中的重点mint m = l + (r - l)/2;// m在左排序数组中，旋转点在 [m+1, r] 中if(nums[m] > nums[r]){l = m + 1;// m 在右排序数组中，旋转点在 [l, m]中    }else if(nums[m] < nums[r]){r = m;}else{// 缩小范围继续判断r--;}}// 返回旋转点return nums[l];}
}

22、BM22 比较版本号

思路：

既然是比较两个字符串每个点之间的数字是否相同，就直接同时遍历字符串比较，因此我们需要使用两个同向访问的指针各自访问一个字符串。

比较的时候，数字前导零不便于我们比较，因为我们不知道后面会出现多少前导零，因此应该将点之间的部分转化为数字再比较才方便。

while(i < n1 && version1[i] != '.'){ num1 = num1 * 10 + (version1[i] - '0');i++;
}

具体做法：

• step 1：利用两个指针表示字符串的下标，分别遍历两个字符串。
• step 2：每次截取点之前的数字字符组成数字，即在遇到一个点之前，直接取数字，加在前面数字乘10的后面。（因为int会溢出，这里采用long记录数字）
• step 3：然后比较两个数字大小，根据大小关系返回1或者-1，如果全部比较完都无法比较出大小关系，则返回0

public class Solution {/*** 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可** 比较版本号* @param version1 string字符串 * @param version2 string字符串 * @return int整型*/public int compare (String version1, String version2) {// write code hereint n1 = version1.length();int n2 = version2.length();int i = 0, j = 0;//遍历直到某个字符串结束while(i < n1 || j < n2){long num1 = 0;//从下一个点前截取数字while(i < n1 && version1.charAt(i) != '.'){num1 = num1 * 10 + (version1.charAt(i) - '0');i++;}//跳过点i++;long num2 = 0;//从下一个点前截取数字while(j < n2 && version2.charAt(j) != '.'){num2 = num2 * 10 + (version2.charAt(j) - '0');j++;}//跳过点j++;//比较数字大小if(num1 > num2){return 1;}if(num1 < num2){return -1;}}//版本号相同return 0;}
}

23、BM23 二叉树的前序遍历