笔试题-数组

二分法

数组二分法
写法:

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;
            if(nums[mid] == target){
                return mid;
            } 
            if(nums[mid] > target){
                right = mid-1;
            } else {
                left = mid+1;
            }
        }

        return -1;
    }
}

进阶:

class Solution {
    public int search(int[] nums, int target) {
        // 避免当 target 小于nums[0] nums[nums.length - 1]时多次循环运算
        if (target < nums[0] || target > nums[nums.length - 1]) {
            return -1;
        }
        int left = 0, right = nums.length - 1;
        while (left <= right) {
            int mid = left + ((right - left) >> 1);
            if (nums[mid] == target)
                return mid;
            else if (nums[mid] < target)
                left = mid + 1;
            else if (nums[mid] > target)
                right = mid - 1;
        }
        return -1;
    }
}

原地移除元素

原地移除指定元素, 使用快慢指针

写法:

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

参考:

class Solution {
    public int removeElement(int[] nums, int val) {
        // 快慢指针
        int slowIndex = 0;
        for (int fastIndex = 0; fastIndex < nums.length; fastIndex++) {
            if (nums[fastIndex] != val) {
                nums[slowIndex] = nums[fastIndex];
                slowIndex++;
            }
        }
        return slowIndex;
    }
}

有序数组的平方

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

写法:

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

参考:

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

长度最小的子数组(滑动窗口)

给定一个含有 n 个正整数的数组和一个正整数 target 。

找出该数组中满足其总和大于等于 target 的长度最小的 连续子数组 [numsl, numsl+1, …, numsr-1, numsr] ，并返回其长度。如果不存在符合条件的子数组，返回 0 。

自写:

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        int i = 0;
        int len = nums.length;
        int sum = 0;
        boolean flag = true;
        for(int j=0; j<nums.length; j++){
            sum += nums[j];
            while (sum >= target){
                len = ((j - i + 1 ) < len) ? (j-i+1) : len;
                sum -= nums[i];
                i ++;
                flag = false;
            }

        }

       if(flag){
           return 0;
       }
        return len;
    }
}

参考:

class Solution {

    // 滑动窗口
    public int minSubArrayLen(int s, 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 >= s) {
                result = Math.min(result, right - left + 1);
                sum -= nums[left++];
            }
        }
        return result == Integer.MAX_VALUE ? 0 : result;
    }
}