Leetcode刷题Day1（C#）

704、二分查找

题目描述：

给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target  ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/binary-search
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解题：

二分法用于有序数列，思路就是每次都找中间量，通过比较大小来缩小范围，因为每次都缩小一半的范围，所以二分法的时间复杂度为O（logn）。示例如下：

 代码如下：

public class Solution {
    public int Search(int[] nums, int target) {
        int left = 0;
        int right = nums.Length-1;
        int mid = (left+right)/2;
        while (left<=right) //左指针在右指针的左边，说明还在正常二分查找的情况下
        {
            if(nums[mid]<target){
                left = mid+1;
                mid = (left+right)/2;
            }
            else if(nums[mid]>target){
                right = mid-1;
                mid = (left+right)/2;
            }
            else if(nums[mid]==target){
                break;
            }
        }
        if (left>right){  //当左指针在右指针的右边，说明遍历了整个有序数列，没有找到目标值
            mid = -1;
        }
        return mid;
        
    }
  

}

最后的运行结果：

简洁一点的版本如下：

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

278、第一个错误的版本

题目描述：

你是产品经理，目前正在带领一个团队开发新的产品。不幸的是，你的产品的最新版本没有通过质量检测。由于每个版本都是基于之前的版本开发的，所以错误的版本之后的所有版本都是错的。

假设你有 n 个版本 [1, 2, ..., n]，你想找出导致之后所有版本出错的第一个错误的版本。

你可以通过调用 bool isBadVersion(version) 接口来判断版本号 version 是否在单元测试中出错。实现一个函数来查找第一个错误的版本。你应该尽量减少对调用 API 的次数。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/first-bad-version
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

这道题可以很好感受到在二分法中，mid=left+(right-left)/2和mid=（left+right）/2的差别。注意⚠️：一定要写mid=left+(right-left)/2 ！！！

之所以要写mid = left+(right-left)/2是因为left+right的值容易溢出int的存储空间，导致代码不能运行。而写成mid = left+(right-left)/2就可以有效地避免溢出的情况。

我第一次就是写的mid=（left+right）/2，代码如下，结果。。。超时了

/* The isBadVersion API is defined in the parent class VersionControl.
      bool IsBadVersion(int version); */

public class Solution : VersionControl {
    public int FirstBadVersion(int n) {
        int left = 1;
        int right = n;
        int mid =0 ;
        while(left<=right){
            mid = (left+right)/2;
            if(IsBadVersion(mid)){
                right = mid;
            }
            if(!IsBadVersion(mid)){
                left = mid+1;
            }
            if(left == right ){
            mid = (left+right)/2;
            break;
            }
        }        
        return mid;
    }
}

而同样的思路，只需要把mid的表达式改成 mid=left+(right-left)/2就可以通过了

/* The isBadVersion API is defined in the parent class VersionControl.
      bool IsBadVersion(int version); */

public class Solution : VersionControl {
    public int FirstBadVersion(int n) {
        int left = 1;
        int right = n;
        int mid =0 ;
        while(left<=right){
            mid = left+(right-left)/2;
            if(IsBadVersion(mid)){
                right = mid;
            }
            if(!IsBadVersion(mid)){
                left = mid+1;
            }
            if(left == right ){
            mid = left+(right-left)/2;
            break;
            }
        }        
        return mid;
    }
}

细节决定成败，我悟了 

35、搜索插入位置

题目描述：

给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。

请必须使用时间复杂度为 O(log n) 的算法。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/search-insert-position
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

 本题的思路其实和704题差不多，只不过是多了一步输出插入位置的下标。

代码如下：

public class Solution {
    public int SearchInsert(int[] nums, int target) {
        int left=0;
        int right=nums.Length-1;
        int mid = 0;
        while(left<=right){
            mid = left+(right-left)/2;
            if(nums[mid]>target){ 
                right = mid-1;
            }
            if(nums[mid]<target){
                left = mid+1;
            }
            if(nums[mid]==target){
                return mid;
            }
        }
        return left;
    }
}

当然这题也是可以用暴力遍历的方法做，但是这样数组的数据量一大，就会慢很多

public class Solution {
    public int SearchInsert(int[] nums, int target) {
        for(int i = 0; i < nums.Length;i++){
        if(nums[i] >= target){
            return i;
        }
    }
    return nums.Length;
    }
}