LeeCode算法入门

(二分查找)Solution704二分查找、Solution278第一个错误的版本、Solution35搜索插入位置、(双指针)Solution977有序数组的平方、Solution189轮转数组、

Solution704二分查找

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

Solution278第一个错误的版本

还是二分查找

 不能用（left+right）/2形式，当left和right都是int，两个值的初始值都超过int限定大小的一半，那么left+right就会发生溢出，所以应该用left+(right-left)/2来防止求中值时候的溢出。

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

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

Solution35搜索插入位置

循环做时，如果整个数组都没有比数大的就返回nums.length做最大数的角标返回

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;
    }
}

二分查找

class Solution {
    public int searchInsert(int[] nums, int target) {
        int n = nums.length;

        // 定义target在左闭右闭的区间，
        int left = 0;
        int right = n - 1;

        while (left <= right) { 
            int mid = left + (right - left) / 2; // 防止溢出
            if (nums[mid] > target) {
                right = mid - 1; // target 在左区间，所以[left, mid - 1]
            } else if (nums[mid] < target) {
                left = mid + 1; // target 在右区间，所以[mid + 1, right]
            } else {
                // 1. 目标值等于数组中某一个元素  return mid;
                return mid;
            }
        }
        // 2.目标值在数组所有元素之前 3.目标值插入数组中 4.目标值在数组所有元素之后 return right + 1;
        return right + 1;
    }
}

Solution977有序数组的平方

 new一个新数组，指针指向新数组最大数，旧数组两端同时平方，比较后塞到新数组。

class Solution {
    public int[] sortedSquares(int[] nums) {
        int l = 0;
        int r = nums.length - 1;
        int[] res = new int[nums.length];
        int j = nums.length - 1;
        while(l <= r){
            if(nums[l] * nums[l] > nums[r] * nums[r]){
                res[j--] = nums[l] * nums[l++];
            }else{
                res[j--] = nums[r] * nums[r--];
            }
        }
        return res;
    }
}

Solution189轮转数组