九章算法系列（#2 Binary Search）-课堂笔记

时间 2019-11-25

标签九章算法系列 binary search 课堂笔记繁體版

原文原文链接

前言面试

先说一些题外的东西吧。受到春跃大神的影响和启发，推荐了这个算法公开课给我，晚上睡觉前点开一看发现课还有两天要开始，本着要好好系统地学习一下算法，因而就爬起来拉上两个小伙伴组团报名了。今天听了第一节课，说真的很实用，特别是对于我这种算法不扎实，而且又想找工做，提升本身的状况。那就很少说废话了，之后每周都写个总结吧，就趁着这一个月好好把算法提升一下。具体就从：课堂笔记、leetcode和lintcode相关习题、hdu和poj相关习题三个方面来写吧。但愿本身可以坚持下来，给你们分享一些好的东西。算法

outline：数组

第一境界：会写程序
- Find First Position of Target
- Find Last Position of Target
第二境界：找到第一个/最后一个知足某个条件的位置/值
- Search a 2D Matrix
- Find Minimum in Rotated Sorted Array
第三境界：保留有解的那一半
- Find Peak Element

课堂笔记学习

二分查找这类题之前接触的也算是比较多的了，因此还算相对熟悉，但今天听老师讲过之后，仍是以为有了不少新的认识，最有印象的就是令狐老师讲的三个境界：优化

1. 第一境界：会写程序spa

这个境界我自认为在刷了那么多leetcode以后算是没有问题的了，套了很多模版，虽然还有一些边界问题考虑不周全，可是通过调试，应该没有什么问题，通过几回面试，也面到过Binary Seach。想必你们也有很好的基础。正如老师说的，这个境界仍是存在一些问题，好比解决二分程序的三大痛点、权衡递归与非递归。对于第一个问题，其实就是start和end的位置选取，好比容易进入死循环，或者容易分不清楚到底应该是start = mid仍是start = mid+ 1等。如下给出一个代码模版，这个也是我以前写二分问题常常会写的样子：调试

int start = 0, end = nums.size() - 1;
while (start < end){
    int mid = (start + end)/2;
    if (...) {...}
    else if (...) {...}
    else {...}
}

想必你们都会把循环条件写成start < end或者start <= end这样的，这样在一些状况下也确实没有问题（这里直接上一个题）：code

　　Find First Position of Targetblog

　　http://www.lintcode.com/zh-cn/problem/first-position-of-target/
排序

给定一个排序的整数数组（升序）和一个要查找的整数target，用O(logn)的时间查找到target第一次出现的下标（从0开始），若是target不存在于数组中，返回-1。

样例

在数组 [1, 2, 3, 3, 4, 5, 10] 中二分查找3，返回2。

这个题应该是Binary Search最基础的题，直接套用模版就能够，如下是这个题的代码（Bug Free）：

    int binarySearch(vector<int> &array, int target) {
        if (!array.size()) return -1;
        int start = 0, end = array.size() - 1;
        while (start < end) {
            int mid = (start + end) >> 1;
            if (array[mid] < target) {
                start = mid + 1;
            } else if (array[mid] > target) {
                end = mid -1;
            } else {
                end = mid;
            }
        }
        if (array[start] == target) return start;
        return -1;
    }

由于比较简单，就再也不多说了，这里须要注意的几个点是，int mid = (start + end) >>1;其实就是int mid = (start + end)/2;由于在面试中若是会位运算的话，仍是可以给面试官留下很好的印象。有的人说直接加起来除以2会溢出，其实start和end不会大到超过int的最大值的，由于一个vector也不会去开辟那么大的空间，可是写成`int mid = (end - start)/2 + start;`也能显得你比较不错。综上，两种方法均可以。在这个题中由于是找第一个与target相等的值，因此用这种方法不会出问题，可是在考虑下面的题，就会出现问题：

　　Find Last Position of Target

　　http://www.lintcode.com/zh-cn/problem/last-position-of-target/

给一个升序数组，找到target最后一次出现的位置，若是没出现过返回-1

样例

给出 [1, 2, 2, 4, 5, 5].

target = 2, 返回 2.

target = 5, 返回 5.

target = 6, 返回 -1.

错误代码以下：

while (start < end) {
        int mid = ( start + end ) >>1;
        if (A[mid] < target) {
　　　　　　　start = mid + 1;
　　　　　} else if ( A[mid] > target) {
　　　　　　　end = mid -1;
　　　　　} else {
　　　　　　　start = mid;
　　　　　}
    }

这里若是这样写的话，代码就会进入死循环，由于在求mid的时候是向左边取整的。考虑这样的一个状况[...,5,5]，假设target为5，那么start就会一直向右靠近，最后到n-2的位置，而end此时为n-1，再次进入循环mid等于n-2，因此就进入了死循环。根据课上老师所说的，建议你们写成start + 1 < end，最后再判断start和end（按照所需前后判断）便可，这种写法适用于全部的状况，不容易出现问题。 ps. 这里把条件写成以下也可行：

while (start + 1 < end) {
    int mid = (start + end)>>1;
    if (A[mid] > target) {
　　　　end = mid;
    } else { 
　　　　start = mid;
　　}
}

由于start和end不论是否包括mid值都不影响最后的结果。这个境界须要理解一个重点：二分法实际上就是把区间变小的问题，把一个长度为n的区间变为n/2，而后再变小，即：

T(n) = T(n/2) + O(1) = O(logn)

经过O(1)的时间，把规模为n的问题变为n/2 当面试的时候，有O(n)的解，若是面试官须要你进一步优化，那么很大可能就是须要用二分O(logn)的方法来作。实际上的步骤：

**区间缩小-> 剩下两个下标->判断两个下标**

**注：不要把缩小区间和获得答案放在一个循环里面，容易出问题，增长难度**

2. 第二境界：找到第一个/最后一个知足某个条件的位置/值

这个境界就是第一个境界的进阶版本，就是可以把一些实际的应用问题转换为二分的核心问题：把具体的问题转变为找到数组中的第一个/最后一个知足某个条件的位置/值。

就很少说了，直接上题吧：

　　Seach a 2D Matrix

　　http://www.lintcode.com/zh-cn/problem/search-a-2d-matrix/

写出一个高效的算法来搜索 m × n矩阵中的值。

这个矩阵具备如下特性：

每行中的整数从左到右是排序的。

每行的第一个数大于上一行的最后一个整数。

样例
考虑下列矩阵：
[
  [1, 3, 5, 7],
  [10, 11, 16, 20],
  [23, 30, 34, 50]
]
给出 target = 3，返回 true

这道题最简单的方式就是对每一行进行一次二分查找，第一行没有找到就找第二行，以此类推，那么时间复杂度为0(nlogn)。若是须要再进行优化，那么能够这样考虑：由于条件中有每行的第一个数大于上一行的最后一个整数。因此咱们能够先对每行的第一个数来进行一个二分查找，找到最后一个不大于target的数（注意这里是二分查找的核心思想）而后再对这一行进行二分查找便可，这样首先对每行的第一个数查找复杂度为0(logn)，再对某一行进行查找，复杂度为O(logn)，因此为O(logn)。代码以下(Bug Free)：

bool searchMatrix(vector<vector<int> > &matrix, int target) {
    if (!matrix.size()||!matrix[0].size()) return false;
    int start = 0, end = matrix.size() - 1;
    while (start + 1 < end) {
        int mid = (end - start)/2 + start;
        if (matrix[mid][0] < target) start = mid;
        else end = mid;
    }
    int new_start = 0,new_end = matrix[0].size()-1;
    int index = matrix[end][0] <= target ?end:start;
    while (new_start + 1 < new_end) {
        int mid = (new_end - new_start)/2 + new_start;
        if (matrix[index][mid] > target) new_end = mid;
        else if (matrix[index][mid] < target)
            new_start = mid;
        else return true;
    }
    if (matrix[index][new_end] == target) return true;
    if (matrix[index][new_start] == target) return true;
    return false;
}

这个题关键在于要对两个端点的把握，仍是二分查找的基本流程：先缩小区间，而后对两个剩余的端点进行判断。

固然这个题也有不须要进行两次计算的方法，由于当前行的全部元素严格大于第一行，因此能够把矩阵考虑为一维的数组，只须要在切换的时候进行一个行和列的转换便可，具体代码以下(Bug Free)：

    bool searchMatrix(vector<vector<int> > &matrix, int target) {
        if (!matrix.size()||!matrix[0].size()) return false;
        int m = matrix.size();
        int n = matrix[0].size();
        int start = 0, end = n * m - 1;
        while (start + 1 < end) {
            int mid = (end - start)/2 + start;
            int x = mid / n;
            int y = mid % n;
            if (matrix[x][y] > target) {
                end = mid;
            } else {
                start = mid;
            }
        }
        int x = start / n;
        int y = start % n;
        if (matrix[x][y] == target) {
            return true;
        }
        x = end / n;
        y = end % n;
        if (matrix[x][y] == target) {
            return true;
        }
        return false;
    }

再来一个题吧：

　　Find Minimum in Rotated Sorted Array

　　http://www.lintcode.com/zh-cn/problem/find-minimum-in-rotated-sorted-array/

假设一个旋转排序的数组其起始位置是未知的（好比0 1 2 4 5 6 7 可能变成是4 5 6 7 0 1 2）。

你须要找到其中最小的元素。

你能够假设数组中不存在重复的元素。

样例

给出[4,5,6,7,0,1,2] 返回 0

这个题若是按照我之前的想法，就是最直观的办法：直接从头遍历，发现某一个值小于前一个值，而且小于后一个值，那么这个值就是最小的。这样的复杂度就是O(n)，我记得有一次面试的时候就是这么回答了，而后遭到了面试官无情的鄙视。这里使用二分的话，是很是有技巧的，这个技巧也是对于以后难一些的题来讲须要掌握的，咱们要时刻不能忘记二分的宗旨：把具体的问题转变为找到数组中的额第一个/最后一个知足某个条件的位置/值。这题其实能够这么考虑：由最小值为中心把两边分开，两边都是递增的，然后一部分的最大值也严格小于前一部分的全部值，显然，最后一部分的最大值就是num[n-1]那么咱们只须要找到比这个值小的第一个值便可。这里是否是又回到了最原始的问题。代码以下(Bug Free)：

    int findMin(vector<int> &num) {
        if (!num.size()) return 0;
        int start = 0, end = num.size() - 1;
        int target = num[end];
        while (start + 1 < end) {
            int mid = (end - start)/2 + start;
            if (num[mid] <= target) {
                end = mid;
            }
            else {
                start = mid;
            }
        }
        if (num[start] <= target) {
            return num[start];
        }
        else {
            return num[end];
        }
    }

这题稍微有一些和以前不同的地方，就是在两个部分之间进行了一个权衡，在start和end的变换的地方，须要你们注意。

3. 第三境界：保留有解的那一半

有了前面两个阶段的铺垫，达到必定的训练之后，应该也差很少可以熟练掌握中等和简单的题了，其实足够深入地理解了二分的精髓之后，能够把几个习题都作一遍，尽可能仍是达到Bug Free的级别吧（这里所说的Bug Free是指可以不用编译器的状况下，直接空手写代码，用眼睛和笔来调试，最后提交后Accepted）。

第三个阶段呢，其实就是回到了二分自己的定义，个人理解就是：二分法其实就是把问题不断缩小为原来的n/2，而后再找到相应的位置进行处理。那么二分法的最高境界就是学会去 保留有答案的那一半，也许你内心会想：这个我原本就知道啊，可是真正到了实际操做的时候，仍是会有搞不清楚的时候。贴出一道题：

　　 Find Peak Element

　　 http://www.lintcode.com/zh-cn/problem/find-peak-element/

给出一个整数数组(size为n)，其具备如下特色：

相邻位置的数字是不一样的

A[0] < A[1] 而且 A[n - 2] > A[n - 1]

假定P是峰值的位置则知足A[P] > A[P-1]且A[P] > A[P+1]，返回数组中任意一个峰值的位置。
样例

给出数组[1, 2, 1, 3, 4, 5, 7, 6]返回1, 即数值 2 所在位置, 或者6, 即数值 7 所在位置.

这个题算是比较简单的题，可是重要的是理解其中的思想，仍是回到二分法第三个阶段的核心： 保留有答案的那一半。这道题只是要求找到其中一个峰值便可。峰值知足的条件就是左边的部分是单调递增的，而右边的部分是单调递减的（若是该点可导，而且导数为0，那么这个点就是峰值），咱们很容易在纸上画出来某个点的四种状况（以下图所示）:

第一种状况：当前点就是峰值，直接返回当前值。

第二种状况：当前点是谷点，不论往那边走均可以找到峰值。

第三种状况：当前点处于降低的中间，往左边走能够到达峰值。

第四种状况：当前点处于上升的中间，往右边走能够达到峰值。

分析了四种状况，那么就容易把有答案的一半保留下来了，接下来就判断是否可以找到峰值便可。代码以下（Bug Free）:

  int findPeak(vector<int> A) {
      if (!A.size()) return 0;
      int start = 0;
      int end = A.size() -1;
      while (start + 1 < end) {
          int mid = (end - start)/2 + start;
          if (A[mid] > A[mid - 1] && A[mid] > A[mid + 1]) {
              return mid;
          } else if (A[mid] <= A[mid+1] && A[mid] >= A[mid -1]) {
              start = mid;
          } else if (A[mid] >= A[mid+1] && A[mid] <= A[mid -1]) {
              end = mid;
          } else {
              start = mid;
          }
      }
      if (start >= 1 && A[start] > A[start - 1] && A[start] > A[start + 1]) return start;
      if (end <= A.size()-2 && A[end] > A[end-1] && A[end] > A[end+1]) return end;
  }

这道题的难点其实就是把各类状况考虑一下，而后把有答案的部分保留下来，基本上就没有问题了。

总结

本文只是挑选了一些比较好的课上的题进行了讲解，还有部分题没有写出来，也会在后续的博客中。

对于我我的而言，二分法算是比较熟悉的一个方法，以前在作微软校招第一题的时候用的就是二分的方法。在面试中也是比较经常使用到的一种方法，由于总有那么一种说法嘛：比0(n)还要快的算法复杂度，那必须就是0(logn)了（这里说的是在通常的面试状况下）那么O(logn)就必然要考虑二分的方法来作了。通常都会与一些排序的序列、在一段有规则的序列等状况中找到符合某个条件的位置/值。这个模块仍是须要多练习，而后就可以很好上手了，若是想要可以在算法面试中有更好的突破，仍是须要去解决一些难一点的题，诸如poj或者hdu这样的应用场景的题。

这也是本人第一次认真写一个技术长文，虽然也没有什么特别深奥的东西，读到这里说明你也是很给我面子的了，以后还会继续更新一些本身的想法和一些好的题目，但愿你们多多支持！