【力扣刷题学习笔记01（数组）】

二分查找（python）

def binary_search(list, item):
    low = 0
    high = len(list) - 1

    while low <= high:
        mid = (low + high) / 2
        guess = list[mid]
        if guess == item:
            return mid
        if guess < item:
            low = mid + 1
        else:
            high = mid - 1
    return None

704.二分查找

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

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

27. 移除元素

给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。

不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。

元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。

class Solution {
     public int removeElement(int[] nums, int val) {
        int slowindex = 0;
        int len = nums.length;
        for(int i = 0;i<len;i++){
            if(nums[i]!=val){
                nums[slowindex] = nums[i];
                slowindex++;
            }
        }
        return slowindex;
    }
}

977. 有序数组的平方

给你一个按 非递减顺序 排序的整数数组 nums，返回 每个数字的平方 组成的新数组，要求也按 非递减顺序 排序。

O(n + nlogn)

class Solution {
    public int[] sortedSquares(int[] nums) {
        for(int i=0;i<nums.length;i++){
            nums[i] *=nums[i];
        }
        QuickSort.quicksort(nums, 0, nums.length-1); //Array.sort(nums);
        return nums;
    }

}
public class QuickSort {
    public static void quicksort(int[] arr, int low, int high){
        int i, j, temp, t;
        if(low > high){
            return;
        }
        i = low;
        j = high;
        temp = arr[low];
        while(i<j){
            while(temp<=arr[j] && i<j){
                j--;
            }
            while(temp>=arr[i] && i<j){
                i++;
            }
            if (i<j) {
                t = arr[i];
                arr[i] = arr[j];
                arr[j] = t;
            }
        }
        arr[low] = arr[i];
        arr[i] = temp;
        quicksort(arr, low, j-1);
        quicksort(arr, j+1, high);
        
    }
}

双指针O(n)

class Solution {
    public int[] sortedSquares(int[] nums) {
        int left = 0, index = nums.length - 1, right = nums.length - 1;
        int[] result = new int[nums.length];
        while(left<=right){
            if(nums[left]*nums[left] > nums[right]*nums[right]){
                result[index--] = nums[left]*nums[left];
                ++left;
            }else{
                result[index--] = nums[right]*nums[right];
                --right;
            }
        }
        return result;
    }

}

209.长度最小的子数组

给定一个含有 n 个正整数的数组和一个正整数 s ，找出该数组中满足其和 ≥ s 的长度最小的 连续 子数组，并返回其长度。如果不存在符合条件的子数组，返回 0。

暴力解法：

• 时间复杂度：O(n^2)
• 空间复杂度：O(1）

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        int sum;
        int len = 0;
        if (nums.length == 0){
            return 0;
        }
        int result = Integer.MAX_VALUE;
        for(int i = 0;i<nums.length;i++){
            sum = 0;
            for(int j = i;j<nums.length;j++){
                sum += nums[j];
                if(sum >= target){
                    len = j - i + 1;
                    result = result < len? result : len;
                    break;
                }
            }
        }
        return result== Integer.MAX_VALUE? 0:result;
    }
}

滑动窗口O(n)

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        int l = 0, r = 0;
        int sum = 0;
        int result = Integer.MAX_VALUE;
        for (r = 0;r<nums.length;r++){ // 右指针
            sum = sum + nums[r];
            while(sum>=target){
                result =Math.min(result, r- l + 1); // 判断取最优值
                sum -= nums[l++];// l++左指针移动
                }
        }
        return result == Integer.MAX_VALUE? 0:result;
    }
}

59. 螺旋矩阵 II

给你一个正整数 n ，生成一个包含 1 到 n2 所有元素，且元素按顺时针顺序螺旋排列的 n x n 正方形矩阵 matrix 。

class Solution {
    public int[][] generateMatrix(int n) {
        int loop = 0;
        int result[][] = new int[n][n];
        int count = 1;
        int start = 0;
        int i = 0, j = 0;
        while(loop++ < n/2){
            for(j = start;j < n-loop;j++){ //j=start,i=start，每次循环横纵坐标的起点
                result[start][j] = count++;
            }
            for(i = start; i < n-loop;i++){
                result[i][j] = count++;
            }
            for(;j >= loop;j--){
                result[i][j] = count++;
            }
            for(;i>= loop;i--){
                result[i][j] = count++;
            }
            start++;
        }
        if(n%2==1){
            result[start][start] = n*n;
        }
        return result;
    }
}