leetcode 二分查找

最简单的二分查找。最基层！

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

---

  

解1：

思路：评论：

简单二分。跟上题本质没啥不同。变换的是left,right,mid的决策条件。

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

class Solution {
public:
    int firstBadVersion(int n) {
        int left=1;
        int right=n;
        int mid=left+(right-left)/2;
        while(left<right){
            if(!isBadVersion(mid)){
                left=mid+1;
            }
            else{
                right=mid;
            }
            mid=left+(right-left)/2;
        }
        return left;
    }
};

---

 

解法1：（自己的代码！）

思路：两次二分查找

注意：开头的两个异常条件很重要，缺一不可。分别判断两个维度的数组是否为空

class Solution {
public:
    bool searchMatrix(vector<vector<int>>& matrix, int target) {
        if(matrix.empty()) return false;
        if(matrix[0].size()==0) return false;
        //先找到外层
        int m=matrix.size();
        int n=matrix[0].size();
        if(matrix[m-1][n-1]<target) return false;
        int i;
        for(i=0;i<m;i++){
            if(matrix[i][n-1]>=target){
                break;
            }
        }
        //再找内层，把二维转化为一维
        int left=0,right=n-1;
        while(left<=right){
            int mid=left+(right-left)/2;
            if(matrix[i][mid]==target) return true;
            else if(matrix[i][mid]>target){
                right=mid-1;
            }
            else if(matrix[i][mid]<target){
                left=mid+1;
            }
        }
        return false;
    }
};

---

 

解法1：

思路：。根据题示，所以如果假如序列是递增的，那么极值就是right。如果是递减的，那么极值就是left。

而这又可以进一步得到化简。题目中说明只要求一个极值就可以。所以直接判断left 和 left+1 。right 和 right-1 。

接下来就是直接取中间mid 。

可以分为4种情况。

1 3 5 

1 3 2 

5 3 1

5 3 5 

这4种。

分别对应着：

            if((nums[mid-1]<nums[mid])&&(nums[mid]>nums[mid+1])) return mid;
            if((nums[mid-1]<nums[mid])&&(nums[mid]<nums[mid+1])){
                left=mid;
            }
            if((nums[mid-1]>nums[mid])&&(nums[mid]>nums[mid+1])){
                length=mid;
            }
            if((nums[mid-1]>nums[mid])&&(nums[mid]<nums[mid+1])){
                left=mid;
            }

class Solution {
public:
    int findPeakElement(vector<int>& nums) {
        if(nums.empty()||nums.size()==1) return 0; 
        int left=0;
        int length=nums.size()-1;
        if(nums[left]>nums[left+1]) return left;
        if(nums[length]>nums[length-1]) return length;
        while(true){
            int mid=left+(length-left)/2;
            if((nums[mid-1]<nums[mid])&&(nums[mid]>nums[mid+1])) return mid;
            if((nums[mid-1]<nums[mid])&&(nums[mid]<nums[mid+1])){
                left=mid;
            }
            if((nums[mid-1]>nums[mid])&&(nums[mid]>nums[mid+1])){
                length=mid;
            }
            if((nums[mid-1]>nums[mid])&&(nums[mid]<nums[mid+1])){
                left=mid;
            }
            
        }
        return left;
    }
};

---

 

解法1：自己写的代码没想到这么NB！
思路：不好描述。自己再理解一下吧。觉得很快！尤其是添加了while循环中的前两句。主要是if(nums[left]==target) return left;这一句。

二分法加双指针的感觉。如果left指向的不等于target。且left+(right-left)/2得到的mid的值也不等于target 。那么就把left++。再继续判断

(感觉还可以继续优化）

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

 还应该参考一下别人的思路：

这个题还没有掌握透彻。

---

 

 解法1：

思路：没想到，和上一题同样的代码。只是返回的是布尔型。可以解决两道题

class Solution {
public:
    bool search(vector<int>& nums, int target) {
        if(nums.size()==0) return false;
        if(nums.size()==1&&nums[0]!=target) return false;
        int left=0;
        int right=nums.size()-1;
        if(nums[right]<target&&target<nums[left]) return false;
        if(nums[right]==target) return true;
        if(nums[left]==target) return true;
        while(left!=right-1){
            if(nums[right]==target) return true;
            if(nums[left]==target) return true;
            int mid=left+(right-left)/2;
            if(nums[mid]==target) return true;
            else if(nums[mid]!=target){
                left++;
            }
        }
        if(nums[left]==target){
            return true;
        }
        return false;
    }
};

同样的感觉没有领略到此题的精髓

---

注意：依次遍历。时间复杂度为O(N) 会超时

解法1：

思路：同上两个题相同。时间复杂度同样没有达到O（logN）。而是O（N/2）

class Solution {
public:
    int findMin(vector<int>& nums) {
        if(nums.size()==0) return 0;
        if(nums.size()==1) return nums[0];
        if(nums.size()==2) return min(nums[0],nums[1]);
        int left=0;
        int right=nums.size()-1;
        int little=nums[left];
        while(left!=right-1){
            little=min(little,nums[left]);
            int mid=left+(right-left)/2;
            little=min(little,nums[mid]);
            left++;
        }
        little=min(little,nums[right]);
        return little;
    }
};

解法2：

思路：二分(来自官方题解）

 

时间复杂度O（logN）

class Solution {
public:
    int findMin(vector<int>& nums) {
        if(nums.size()==1) return nums[0];
        int left=0;
        int right=nums.size()-1;
        //如果是有序数组
        if(nums[left]<nums[right]){
            return nums[left];
        }
        //二分查找：
        while(right>=right){
            int mid=left+(right-left)/2;
            if(nums[mid]>nums[mid+1]) return nums[mid+1];
            if(nums[mid-1]>nums[mid]) return nums[mid];
            if(nums[mid]>nums[left]){
                left=mid+1;
            }
            else
                right=mid-1;
        }
        return -1;
    }
};

---

 

解法1：

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        vector<int> res;
        for(int i = 0;i<nums1.size();i++){
            for(int j=0;j<nums2.size();j++){
                if(nums1[i] == nums2[j]){
                    res.push_back(nums1[i]);
                    break;
                }
            }
        }
        set<int> st(res.begin(),res.end());
        res.assign(st.begin(),st.end());//assign函数相当于拷贝函数
        return res;
    }
};

---

 

 解法1：

class Solution {
public:
    vector<int> intersect(vector<int>& nums1, vector<int>& nums2) {
        sort(nums1.begin(),nums1.end());
        sort(nums2.begin(),nums2.end());
        int size1 = nums1.size();
        int size2 = nums2.size();
        int cur1 = 0, cur2 = 0;
        vector<int> result;
        while(cur1 < size1 && cur2 < size2){
            if(nums1[cur1] == nums2[cur2]){
                result.push_back(nums1[cur1]);
                cur1++;
                cur2++;
            }
            else if(nums1[cur1] < nums2[cur2]){
                cur1++;
            }
            else if(nums1[cur1] > nums2[cur2]){
                cur2++;
            }
        }
        return result;
    }
};

---

 

 解法1:效率低，递归。而且还使用了swap 函数，面试时不能使。

class Solution {
public:
    void reverseString(vector<char>& s) {
        if(s.empty()){
            return;
        }
        recursive(s,0,s.size()-1);
    }
    void recursive(vector<char>& s,int start,int end){
        if(start > end){
            return;
        }
        recursive(s,start+1,end-1);
        swap(s[start],s[end]);
    }
};

解法2：

思路：迭代进行交换。双指针

class Solution {
    public void reverseString(char[] s) {
        int start = 0, end = s.length-1;
        char temp;
        while(start < end){
            temp = s[start];//交换
            s[start] = s[end];
            s[end] = temp;
            start++;
            end--;
        }
        
    }
}

解法3：双指针 异或交换。

普及一下知识：

class Solution {
public:
    void reverseString(vector<char>& s) {
        int i = 0, j = s.size() - 1;
        while(i < j){
            s[i] = s[i] ^ s[j];
            s[j] = s[i] ^ s[j];
            s[i] = s[i] ^ s[j];
            i++;
            j--;
        }
    }
};

---