Leetcode-11.19-数组

数组中的方法有

• 双指针法
• 二分法
• 滑动窗口法

移除元素-简单

用双指针法解题，两个指针可以从同一个起点出发，也可以一个从前往后，一个从后往前。

class Solution {
    public int removeElement(int[] nums, int val) {
        int slow=0;
        //快指针一直往前走，慢指针满足条件再往前走
        for(int fast=0;fast<nums.length;fast++){
            if(nums[fast]!=val){
                nums[slow]=nums[fast];
                slow++;
            }
        }
        return slow;
    }
}

有序数组的平方-简单

自己做的有点复杂了，先找到最小的然后往两边遍历，其实从两边往中间遍历会简单很多。

class Solution {
    public int[] sortedSquares(int[] nums) {
        if(nums.length==0){
            return nums;
        }else if(nums.length==1){
            return new int[]{nums[0]*nums[0]};
        }else if(nums.length==2&&Math.pow(nums[0],2)<=Math.pow(nums[1],2)){
            return new int[]{nums[0]*nums[0],nums[1]*nums[1]};
        }else if(nums.length==2&&Math.pow(nums[0],2)>Math.pow(nums[1],2)){
            return new int[]{nums[1]*nums[1],nums[0]*nums[0]};
        }
        int[] r=new int[nums.length];
        //采用双指针法，先找到绝对值最小的那个元素，然后往两边查找
        int minAbsIndex=0;
        for(int i=1;i<nums.length-1;i++){
            if(Math.pow(nums[i],2)<=Math.pow(nums[i-1],2)&&Math.pow(nums[i],2)<Math.pow(nums[i+1],2)&&Math.pow(nums[i],2)<Math.pow(nums[minAbsIndex],2)){
                minAbsIndex=i;
            }
        }
        if(minAbsIndex==0&&Math.pow(nums[nums.length-1],2)<Math.pow(nums[0],2)){
            minAbsIndex=nums.length-1;
        }
        int lIndex=minAbsIndex-1;
        int rIndex=minAbsIndex+1;
        r[0]=nums[minAbsIndex]*nums[minAbsIndex];
        for(int j=1;j<nums.length;j++){
            if(lIndex<0){
                r[j]=nums[rIndex]*nums[rIndex];
                rIndex++;
                continue;
            }
            if(rIndex>nums.length-1){
                r[j]=nums[lIndex]*nums[lIndex];
                lIndex--;
                continue;
            }
            if(nums[rIndex]*nums[rIndex]<=nums[lIndex]*nums[lIndex]){
                r[j]=nums[rIndex]*nums[rIndex];
                rIndex++;
            }else{
                r[j]=nums[lIndex]*nums[lIndex];
                lIndex--;
            }
        }
        return r;

    }
}

长度最小的子数组-中等

因为没有认真读题耗费了很长时间。。。。。。

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        int sum=0;
        int minSum=nums.length+1;
        int r=0;
        int l=0;
        while(r<=nums.length){
            if(sum>=target){
                if(r-l<minSum){
                    minSum=r-l;
                    sum-=nums[l];
                    l++;
                }else{
                    sum-=nums[l];
                    l++;
                }
            }else if(sum<target){
                if(r>=nums.length){
                    break;
                }
                sum+=nums[r];
                r++;
            }
        }
        return minSum==nums.length+1?0:minSum;
    }
}

螺旋数组

这道题的关键在于找到固定的规则一圈圈遍历下去。

class Solution {
    public int[][] generateMatrix(int n) {
        int col=0;
        int row=0;
        int num=1;
        int t=1;
        int[][] r=new int[n][n];
        while(t<=n/2){
            for(col=t-1;col<n-t;col++){
                r[row][col]=num;
                num+=1;
            }
            for(row=t-1;row<n-t;row++){
                r[row][col]=num;
                num+=1;
            }
            for(;col>t-1;col--){
                r[row][col]=num;
                num+=1;
            }
            for(;row>t-1;row--){
                r[row][col]=num;
                num+=1;
            }
            row++;
            t++;
        }
        if(n%2==0){
            return r;
        }else{
            r[n/2][n/2]=n*n;
            return r;
        }
    }
}