leetcode_33_34_二分搜素

最新推荐文章于 2022-01-16 21:25:52 发布

Allianzcortex

最新推荐文章于 2022-01-16 21:25:52 发布

阅读量604

点赞数

分类专栏： leetcode

本文链接：https://blog.csdn.net/Allianzcortex/article/details/45251419

版权

leetcode 专栏收录该内容

14 篇文章 0 订阅

订阅专栏

传送门：https://leetcode.com/problems/search-in-rotated-sorted-array/

思路：

这里首先先提供一下自己一开始写的代码：

class Solution {
public:
	int binary_search(vector<int>& vec,int begin,int end,int target)
	{
		while(begin<=end)
		{
			int mid=begin+(end-begin)/2;
			if(vec[mid]==target) return mid;
			if(vec[mid]>target) end=mid-1;
			else begin=mid+1;
		}
		return -1;

	}
    int search(vector<int>& nums, int target) {
        int i,j,k;
        bool flag=true;

        int begin=0,end=nums.size()-1;
        if(begin==end) return binary_search(nums,0,0,target);
        if(nums[begin]<nums[end]) return binary_search(nums,0,end,target);
        else
        {
        	for(i=1;i<=nums.size()-1;i++)
        	{
        		if((nums[i]>nums[i-1] && nums[i]<nums[i+1]) || (nums[i]<nums[i-1] && nums[i]>nums[i-1]))
        		return i;
        	}
        	return (binary_search(nums,begin,i,target)==-1?binary_search(nums,begin,end,target):binary_search(nums,i+1,end,target));
        }

    }
};

现在看来简直乱得一塌糊涂。

自己的思路是正确的：如果vec[begin]<vec[end]，那么说明是有序的，可以直接用二分搜素。

((nums[i]>nums[i-1] && nums[i]<nums[i+1]) || (nums[i]<nums[i-1] && nums[i]>nums[i-1])

如果不能满足，那么找出中间节点，就是上述代码所满足的i；

这样的代码毫无美感，过了2个测试用例后就再也过不去了。

所以自己转换思路，用另一种方法找到不是顺序队列的范围：递归。

设置search()函数，用(begin,mid)/(mid+1,end)依次去试。

还有一点是在看discuss后注意到的，要用vec[begin]<=vec[end]来判断，应对出现长度为1数组的情况。

AC代码如下：

class Solution {
public:
	int binary_search(vector<int>& vec,int begin,int end,int target)
	{
		while(begin<=end)
		{
			int mid=begin+(end-begin)/2;
			if(vec[mid]==target) return mid;
			if(vec[mid]>target) end=mid-1;
			else begin=mid+1;
		}
		return -1;

	}
    int search(vector<int>& vec,int begin,int end,int target)
    {
        if(vec[begin]<=vec[end]) return binary_search(vec,begin,end,target);
        else
        {
            int mid=begin+(end-begin)/2;
            int temp=search(vec,begin,mid,target);
            if(temp!=-1) return temp;
            return search(vec,mid+1,end,target);
        }
    }
    int search(vector<int>& nums, int target) {
        int i,j,k;

        int begin=0,end=nums.size()-1;
        return search(nums,begin,end,target);
    }
        

    
};

34.传送门：

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

这道题要求在O(logn)的时间复杂度内解决问题。

提供两套思路：

第一种是最常规的解决方法，从左右对每一个元素进行比较：AC代码1:

class Solution {
public:
    vector<int> searchRange(vector<int>& nums, int target) {
        int length=nums.size();
        int i,j,k;
        int start=-1,end=-1;
        for(i=0;i<length;i++)
        {
            if(nums[i]==target) {start=i;break;}


        }
        for(int j=length-1;j>=0;j--)
        {
            if(nums[j]==target) {end=j;break;}
        }
        vector<int> vec;
        if(start==end&&start==-1) {vec.push_back(-1);vec.push_back(-1);return vec;};
        vec.push_back(start);vec.push_back(end);  // 不能用vec[0]=-1这样直接赋值的方式？
        return vec;

        
    }
};

AC代码2：是用二分搜索的思路：

35. search_insert

传送门:https://leetcode.com/problems/search-insert-position/

首先上AC代码：

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

上面的代码是只求AC的情况下写的，显然search和Insert是两个可以合并在一起的步骤，明天继续：

69 传送门：https://leetcode.com/problems/sqrtx/

开个玩笑，先水一下：AC代码1：

class Solution {
public:
    int mySqrt(int x) {
        return int(sqrt(x));
        
    }
};

正规的思路是用二分搜索进行依次查找：

注意到mid*mid是一个极大的数值，所以用long long的数据类型来表示：

AC代码2:

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

        return binary_search(x);
    }
};

传送门：

解题思路：先竖向查找，找出可能在的行。再横向二分查找，看是否有对应数值。

这道题唯一比较尴尬的是如果把自己AC代码里的注释去掉，会提醒无法通过测试用例[[1,3,5,7],[10,11,16,20],[23,30,34,50]], 30

而自己注释就是为了专门应对要求数值出现在最后一行的情况，sigh^……

AC代码1：

class Solution {
public:
    bool binary_search(vector<int> vec,int target)
    {
        int begin=0,end=vec.size()-1;
        while(begin<=end)
        {
            int mid=begin+(end-begin)/2;
            if(vec[mid]==target) return true;
            if(vec[mid]<target) begin=mid+1;
            else end=mid-1;
        }
        return false;

    }
    bool searchMatrix(vector<vector<int> > &matrix, int target) {

        int i;
        bool flag=false;
        if(matrix.size()==1) return binary_search(matrix[0],target);
        for(i=0;i<matrix.size();i++)
        {
            if(matrix[i][0]==target) return true;
        }
        for(i=0;i<matrix.size()-1;i++)
        {
            if(matrix[i][0]<target && matrix[i+1][0]>target) {flag=true;break;}
        }
        /*if(i==matrix.size()-2) 
        {
            if(binary_search(matrix[i+1],target)) return true;
        }*/
        //if(!flag) return false;

        return binary_search(matrix[i],target); 

    }
};

AC代码2：后续：自己应该是在判断i的大小这里出现了问题，更改注释后重新AC：

class Solution {
public:
    bool binary_search(vector<int> vec,int target)
    {
        int begin=0,end=vec.size()-1;
        while(begin<=end)
        {
            int mid=begin+(end-begin)/2;
            if(vec[mid]==target) return true;
            if(vec[mid]<target) begin=mid+1;
            else end=mid-1;
        }
        return false;

    }
    bool searchMatrix(vector<vector<int> > &matrix, int target) {

        int i;
        bool flag=false;
        if(matrix.size()==1) return binary_search(matrix[0],target);
        for(i=0;i<matrix.size();i++)
        {
            if(matrix[i][0]==target) return true;
        }
        for(i=0;i<matrix.size()-1;i++)
        {
            if(matrix[i][0]<target && matrix[i+1][0]>target) {flag=true;break;}
        }
        if(i==matrix.size()-1) 
        {
            if(binary_search(matrix[i],target)) return true;
        }
        if(!flag) return false;

        return binary_search(matrix[i],target); 

    }
};

81 search_rotated_array_2

传送门：

这道题感觉不会太难，但AC起来总是有难度：

要注意的是：如果数组[1,2,3,3]进行rotate后可以变为[3,1,2,3]，就不能简单地用vec[begin]<=vec[end]来判断是否进行二分搜素

AC代码：

class Solution {
public:
    int binary_search(vector<int>& vec,int begin,int end,int target)
    {
        while(begin<=end)
        {
            int mid=begin+(end-begin)/2;
            if(vec[mid]==target) return true;
            if(vec[mid]>target) end=mid-1;
            else begin=mid+1;
        }
        return false;

    }
    int search(vector<int>& vec,int begin,int end,int target)
    {
        if(begin>=end) return vec[begin]==target;
        if(vec[begin]<vec[end]) return binary_search(vec,begin,end,target);
        else
        {
            int mid=begin+(end-begin)/2;
            int temp=search(vec,begin,mid,target);
            if(temp) return true;
            return search(vec,mid+1,end,target);
        }
    }
    bool search(vector<int>& nums, int target) {
        int i,j,k;

        int begin=0,end=nums.size()-1;
        return search(nums,begin,end,target);
    }
        

    
};

153,154

和之前的几个实例完全是一样的情况。

AC代码_153:

Allianzcortex

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
leetcode_33_34_二分搜素

传送门：https://leetcode.com/problems/search-in-rotated-sorted-array/思路：这里首先先提供一下自己一开始写的代码：class Solution {public: int binary_search(vector& vec,int begin,int end,int target) { while(begin<=end
复制链接

扫一扫