算法与数据结构总结1 二分查找与旋转排序数组

时间：2015-10-27 23:48:54 阅读：339 评论：0 收藏：0 [点我收藏+]

标签：

一. 二分搜索（Binary Search）模板及其理解

1.通用模板，解决start, end, mid, <(<=), >(>=)等问题

http://www.lintcode.com/en/problem/binary-search/

class Solution {
public:
    /**
     * @param nums: The integer array.
     * @param target: Target number to find.
     * @return: The first position of target. Position starts from 0. 
     */
    int binarySearch(vector<int> &array, int target) {
        // write your code here
        if(array.size() == 0){
            return -1;
        }
        int start = 0, end = array.size() - 1;
        while(start + 1 < end){
            int mid = start + (end - start) / 2;
            if(array[mid] == target){
                end =  mid;
            }else if(array[mid] < target){
                start = mid;
            }
            else{
                end = mid;
            }
        }
        if(array[start] == target){
            return start;
        }
        if(array[end] == target){
            return end;
        }
        return -1;
    }
};

注意事项：

1). start + 1 < end (最后会剩下start, end两项)；

2). mid = start + (end - start) / 2; (避免出现start + end越界情况)；

3). A[mid] 依次比较 ==, <, >；

4). A[start], A[end]与target比较。（对应first / last position问题，对应的比较顺序不用）

2. 对二分搜索的理解

1) 字面意义的二分搜索，对有序数组取中间值，比较并折半删除

2）first / last position问题，利用模板可以很好地解决

3）只有能判断解在某部分集合里，就可以将规模缩小（不一定是简单的在中间位置左侧或右侧），若每次规模近似缩小一半，仍然是二分的思路；

即将一个O(n)问题通过O(1)操作转化成一个O(k/2)的问题。

4）当复杂度要求O(logn)时，往往可以考虑二分搜索

二常见问题

2.1 基础二分问题变种

1）Search a 2D matrix i

https://leetcode.com/problems/search-a-2d-matrix/

思路：将二维矩阵看做线性序列，则为典型二分搜索问题，所以只需要线性序列与二维数组小标的对应

即： mid / n , mid % n

class Solution {
public:
    bool searchMatrix(vector<vector<int>>& matrix, int target) {
        int m = matrix.size(), n = matrix[0].size();
        int start = 0, end = m*n - 1;
        while(start + 1 < end){
            int mid = start + (end - start) / 2;
            if(matrix[mid/n][mid%n] == target){
                return 1;
            }
            else if(matrix[mid/n][mid%n] < target){
                start = mid;
            }
            else{
                end = mid;
            }
        }
        if (matrix[start/n][start%n] == target) {
            return 1;
        }
        if (matrix[end/n][end%n] == target) {
            return 1;
        }
        return 0;
    }
};

Search a 2D matrix i

2）Search a 2D matrix ii

https://leetcode.com/problems/search-a-2d-matrix-ii/

思路：根据矩阵的性质，从左下角向右上寻找。

如果target大于当前元素，当前列上方元素可删除，所以向右走一步；

如果target小于当前元素，当前行右方元素可删除，所以向上走一步。

class Solution {
public:
    bool searchMatrix(vector<vector<int>>& matrix, int target) {
        int m = matrix.size();
        int n = matrix[0].size();
        int i = m - 1, j = 0;
        while(i >= 0 && j < n){
            if(matrix[i][j] == target){
                return 1;
            }
            else if(matrix[i][j] < target){
                j++;
            }
            else{
                i--;
            }
        }
        return 0;
    }
};

Search a 2D matrix ii

2.2 first/last position 问题

1）Search for a range

https://leetcode.com/problems/search-for-a-range/

思路：使用两遍模板，分别找到first 和 last position，则找到对应区间

class Solution {
public:
    vector<int> searchRange(vector<int>& nums, int target) {
        if(nums.size() == 0){
            return vector<int>{0,0};
        }
        int start = 0, end = nums.size() - 1;
        vector<int> range;
        // search for left bound
        while(start + 1 < end){
            int mid = start + (end - start) / 2;
            if(nums[mid] == target){
                end = mid;
            }
            else if(nums[mid] < target){
                start = mid;
            }
            else{
                end = mid;
            }
        }
        if(nums[start] == target){
            range.push_back(start);
        }
        else if(nums[end] == target){
            range.push_back(end);
        }
        else{
            range.push_back(-1);
        }
        start = 0;
        end = nums.size() - 1;
        // search for right bound
         while(start + 1 < end){
            int mid = start + (end - start) / 2;
            if(nums[mid] == target){
                start = mid;
            }
            else if(nums[mid] < target){
                start = mid;
            }
            else{
                end = mid;
            }
        }
        if(nums[end] == target){
            range.push_back(end);
        }
        else if(nums[start] == target){
            range.push_back(start);
        }
        else{
            range.push_back(-1);
        }
        return range;
    }
};

Search for a range

2) Search insert position

https://leetcode.com/problems/search-insert-position/

思路：在数组中找到第一个大于等于target的位置（find first position）

class Solution {
public:
    int searchInsert(vector<int>& nums, int target) {
        if(nums.size() == 0){
            return 0;
        }
        int start = 0,end = nums.size() - 1;
        while(start + 1 < end){
            int mid = start + (end - start) / 2;
            if(nums[mid] == target){
                end = mid;
            }
            else if(nums[mid] < target){
                start = mid;
            }
            else{
                end = mid;
            }
        }
        if(nums[start] >= target){
            return start;
        }
        else if(nums[end] >= target){
            return end;
        }
        else{
            return end + 1;
        }
    }
};

Search insert position

3) Find bad version

https://leetcode.com/problems/first-bad-version/

思路：找到第一个bad version(first position)

// Forward declaration of isBadVersion API.
bool isBadVersion(int version);

class Solution {
public:
    int firstBadVersion(int n) {
        if(n == 0){
            return 0;
        }
        int start = 1, end = n;
        while(start + 1 < end){
            int mid = start + (end - start) / 2;
            if(isBadVersion(mid)){
                end = mid;
            }
            else {
                start = mid;
            }
        }
        if(isBadVersion(start)){
            return start;
        }
        if(isBadVersion(end)){
            return end;
        }
    }
};

find bad version

4) Sqrt(x)

https://leetcode.com/problems/sqrtx/

思路：找到最后一个平方小于等于x的数

class Solution {
public:
    int mySqrt(int x) {
        long long start = 0, end = x;
        while(start + 1 < end){
            long long mid = start + (end - start) / 2;
            if(mid*mid == x){
                return mid;
            }
            else if(mid * mid < x){
                start = mid;
            }
            else{
                end = mid;
            }
        }
        if(end * end <= x){
            return end;
        }
        return start;
    }
};

Sqrt(x)

3 较复杂二分搜索问题（包含旋转排序数组内搜索）

这几个问题仍然采用二分思想，但二分后删除部分集合的调节并不明显，往往需要通过画图帮助理解。

同时此类问题很多也可以转换成增加条件的first position / last position问题，从而使用二分模板。

1) Find peak element

https://leetcode.com/problems/find-peak-element/

思路：因为题目假设了num[-1] = num[n] = - 所以对于nums[mid]来讲，其与左右元素之间无非只有三种情况：

（1） nums[mid-1] < nums[mid] && nums[mid] > nums[mid+1] ，此时mid即为peak element;

（2） nums[mid-1] < nums[mid] && nums[mid] < nums[mid+1]，此时删除数组左半部分仍然可保证有peak element, mid = start;

（3）nums[mid-1] > nums[mid] && nums[mid] > nums[mid+1], 此时删除数组左半部分仍然可保证有peak element,mid = end;

（4）在波谷位置，随意左右均可。

class Solution {
public:
    int findPeakElement(vector<int>& nums) {
        int start = 0, end = nums.size() - 1;
        while(start + 1 < end ){
            int mid = start + (end - start) / 2;
            if(nums[mid - 1] < nums[mid] && nums[mid] > nums[mid+1]){
                return mid;
            }
            else if(nums[mid - 1] < nums[mid] && nums[mid] < nums[mid + 1]){
                start = mid;
            }
            else{
                end = mid;
            }
        }
        if(nums[start] > nums[end]){
            return start;
        }
        return end;
    }
};

find peak element

2) Find Minimum in Rotated Sorted Array

https://leetcode.com/problems/find-minimum-in-rotated-sorted-array/

思路：根据旋转排序数组性质，问题转化为find first element which is bigger than nums[nums.size() - 1];

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

Find Minimum in rotated sorted array

3) Search in Rotated Sorted Array

https://leetcode.com/problems/search-in-rotated-sorted-array/

思路：分情况进行“二分”的删除区间操作

首先区分target与nums[nums.size() - 1]的关系

其次在不同区间内，根据target与nums[mid]的关系进行相关删除区间操作。

class Solution {
public:
    int search(vector<int>& nums, int target) {
        if(nums.size() == 0){
            return -1;
        }
        int start = 0, end = nums.size() - 1;
        int temp = nums[end];
        while(start + 1 < end){
            int mid = start + (end - start) / 2;
            if(nums[mid] == target){
                return mid;
            }
            if(temp == target){
                return nums.size() - 1;
            }
            if(temp < target){
                if(nums[mid] < target && nums[mid] > temp){
                    start = mid;
                }
                else{
                    end = mid;
                }
            }
            else{
                if(nums[mid] > target && nums[mid] < temp){
                    end = mid;
                }
                else{
                    start = mid;
                }
            } 
        }
        if(nums[start] == target){
            return start;
        }
        if(nums[end] == target){
            return end;
        }
        return -1;
    } 
};

Search in rotated sorted array

4) Median of Two Sorted Arrays

https://leetcode.com/problems/median-of-two-sorted-arrays/

思路：取两个数组中长度较小的那个，利用归并排序的思想，我们从a和b中一共拿k个数看下假设 length(a) < length(b)

从a中取pa = min(k / 2, length(a))个元素，从b中取pb = k – pa个元素；

如果a[pa - 1] < b [pb - 1], 说明a取少了，第k个在a后半部分和b前半部分，反之同理。

算法与数据结构总结1 二分查找与旋转排序数组

标签：

原文地址：http://www.cnblogs.com/wangxiaobao/p/4915853.html

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)

周排行