LeetCode每日三题（六）数组

一、最大子数组和

自己答案：

class Solution {
    public int maxSubArray(int[] nums) {
        int begin=0;
        int end=0;
        if(nums==null){
            //如果数组非空
            return 0;
        }else if(nums.length==1){
            //如果数组只有一个元素
            return nums[0];
        }
        //初值选为数组的第一个值
        int result=nums[0];
        int i=0;
        int sum=0;
        while(end<nums.length){
            //只要end指针遍历全部元素
            if(begin!=end){
                //如果begin不等于end
                //说明end这一轮正常后移
                sum += nums[end];
            }else{
                //说明end和begin重置了
                sum=nums[end];
            }
            if(result<sum){
                result=sum;
            }
            if(i+1!=nums.length){
                //只要没有到达最后一个元素
                if(nums[i+1]>=sum+nums[i+1]){
                    //前面所有元素之和的sum如果大于当前元素加上sum
                    //表示选择当前元素并且抛弃掉前面所有的元素
                    begin=i+1;
                    end=begin;
                }else {
                    //否则正常+1
                    end++;
                }}else{
                //到达最后一个直接结束循环
                break;
            }
            i++;
        }
        return result;
    }
}

标准答案：

class Solution {
    public int maxSubArray(int[] nums) {
        int pre = 0, maxAns = nums[0];
        for (int x : nums) {
            pre = Math.max(pre + x, x);
            maxAns = Math.max(maxAns, pre);
        }
        return maxAns;
    }
}

二、合并区间

自己答案：

class Solution {
    public int[][] merge(int[][] intervals) {
        //先按区间左边数字进行排序
        Arrays.sort(intervals, new Comparator<int[]>() {
            @Override
            public int compare(int[] o1, int[] o2) {
                return o1[0]-o2[0];
            }
        });

        int index=0;
        ArrayList<int[]> list=new ArrayList<>();
        while(index<intervals.length){
            int left=intervals[index][0];
            int right=intervals[index][1];
            int temp=index+1;
            while(temp<intervals.length&&(right>=intervals[temp][0])){
                //如果index后面的区间满足 重叠的条件
                //若这个区间的右边大于index区间的右边，right更新
                //temp++ 直到下一次不满足
                if(intervals[temp][1]>right){
                    right = intervals[temp][1];
                }
                temp++;
            }
            //将新区间记录在集合中
            list.add(new int[]{left,right});
            //index直接从不满足的那个区间开始新一轮判断
            index=temp;
        }
        return list.toArray(new int[list.size()][2]);
    }
}

标准答案：

class Solution {
    public int[][] merge(int[][] intervals) {
        if (intervals.length == 0) {
            return new int[0][2];
        }
        Arrays.sort(intervals, new Comparator<int[]>() {
            public int compare(int[] interval1, int[] interval2) {
                return interval1[0] - interval2[0];
            }
        });
        List<int[]> merged = new ArrayList<int[]>();
        for (int i = 0; i < intervals.length; ++i) {
            int L = intervals[i][0], R = intervals[i][1];
            if (merged.size() == 0 || merged.get(merged.size() - 1)[1] < L) {
                merged.add(new int[]{L, R});
            } else {
                merged.get(merged.size() - 1)[1] = Math.max(merged.get(merged.size() - 1)[1], R);
            }
        }
        return merged.toArray(new int[merged.size()][]);
    }
}

三、轮转数组

自己答案：

class Solution {
    public void rotate(int[] nums, int k) {
     //  int[] result=new int[nums.length];
        int length = nums.length;
        if(k==length){

        }else{
            Queue<Integer> queue=new LinkedList<>();
            int time=length-k%length;
            for (int num : nums) {
                queue.add(num);
            }
            //屁股后面k个元素移到前面
            int[] arr=new int[time];
            while(time>0){
                int value=queue.remove();
                queue.add(value);
                time--;
            }
            int size=queue.size();
            for(int i=0;i<size;i++){
                nums[i]=queue.remove();
            }
        }
    }
}

标准答案：

class Solution {
    public void rotate(int[] nums, int k) {
        int n = nums.length;
        int[] newArr = new int[n];
        for (int i = 0; i < n; ++i) {
            newArr[(i + k) % n] = nums[i];
        }
        System.arraycopy(newArr, 0, nums, 0, n);
    }
}

class Solution {
    public void rotate(int[] nums, int k) {
        k %= nums.length;
        reverse(nums, 0, nums.length - 1);
        reverse(nums, 0, k - 1);
        reverse(nums, k, nums.length - 1);
    }

    public void reverse(int[] nums, int start, int end) {
        while (start < end) {
            int temp = nums[start];
            nums[start] = nums[end];
            nums[end] = temp;
            start += 1;
            end -= 1;
        }
    }
}