力扣刷题记录【二分查找、移除元素、长度最小的子数组、螺旋矩阵】23/11/11

704 二分查找【数组 | 二分查找】

二分查找

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

递归

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

27 移除元素【数组 | 双指针】

 public int removeElement(int[] nums, int val) {
        int slow = 0;//慢指针
        for (int fast = 0; fast < nums.length; fast++) {
            if (nums[fast]!=val){//快指针遍历至不等于val的值,则慢指针后移
                nums[slow++] = nums[fast];
            }
        }
        return slow;
    }

977 有序数组的平方【数组 | 双指针】

 public int[] sortedSquares(int[] nums) {
        // 左指针，指向原数组最左边
        int left = 0;
        // 有指针，指向原数组最右边
        int right = nums.length - 1;
        // 创建一个新数组，存储平方值
        int[] result = new int[nums.length];
        // 得到元素值平方值，从新数组最后位置开始写
        int write = nums.length - 1;
        // 左右指针相遇（逐渐靠拢的过程）之后不再循环
        while (left <= right) {
            // 如果原数组的左指针对应的平方值大于右指针，那么往新数组最后位置写入左指针对应的平方值
            if (nums[left] * nums[left] > nums[right] * nums[right]) {
                result[write] = nums[left] * nums[left];
                // 左指针右移
                left++;
                // 移动新数组待写入的位置
                write--;
            } else {
                result[write] = nums[right] * nums[right];
                right--;
                write--;
            }
        }
        return result;
    }

209 长度最小的子数组【数组 | 前缀和 | 滑动窗口】

 public int minSubArrayLen(int target, int[] nums) {
        int left = 0;
        int sum = 0;
        int result = Integer.MAX_VALUE;
        for (int right = 0; right < nums.length; right++) {
            sum += nums[right];
            while (sum >= target) {
                result = Math.min(result, right - left + 1);
                sum -= nums[left++];
            }
        }
        return result == Integer.MAX_VALUE ? 0 : result;
    }

59 螺旋矩阵【数组 | 循环】

public int[][] generateMatrix(int n) {
        //定义四个边界
        /**
         * r,b两个边界不能设为n，因为输出大小为【n】【n】的数组其上限就是n-1；
         */
        int[][] result = new int[n][n];
        int l = 0;
        int r = n - 1;
        int t = 0;
        int b = n - 1;
        int num = 1;
        while (num <= n * n) {
            for (int i = l; i <= r; i++) result[t][i] = num++;
            t++;
            for (int i = t; i <= b; i++) result[i][r] = num++;
            r--;
            for (int i = r; i >= l; i--) result[b][i] = num++;
            b--;
            for (int i = b; i >= t; i--) result[i][l] = num++;
            l++;
        }
        return result;
    }