leetcode-刷题顺序推荐

题目分类及刷题顺序推荐

一. 数组

数组的遍历
数组的遍历 485、495、414、628

485. 最大连续 1 的个数
     输入：[1,1,0,1,1,1]
     输出：3
     解释：开头的两位和最后的三位都是连续 1 ，所以最大连续 1 的个数是 3.

public int findMaxConsecutiveOnes(int[] nums) {
   
        int left = 0;
		int right = 0;
		int max = 0;
		while (right < nums.length) {
   
			while (right < nums.length && nums[right] == 1) right++;
			max = Math.max(max, right - left);
            right++;
            left = right;
		}
		return max;    
    }

495. 提莫攻击
     

// 思路: 第二次开始时间与第一次结束时间是否有交叉,减去两者时间交叉部分的即可
public int findPoisonedDuration(int[] timeSeries, int duration) {
   
        if (timeSeries.length == 0) return 0;
		int result = duration;
		int preTime = timeSeries[0] + duration - 1;
		int endTime = 0;
		for (int i = 1; i < timeSeries.length; i++) {
   
			endTime = timeSeries[i] + duration - 1;
			result += preTime >= timeSeries[i] ? endTime - preTime : duration;
			preTime = endTime;
		}
		return result;
	}

414. 第三大的数
     

//思路: 设置3个变量直接比较大小,排除1 2 3名
public int thirdMax(int[] nums) {
   
		long first = Long.MIN_VALUE;
		long second = Long.MIN_VALUE;
		long third = Long.MIN_VALUE;
		for (int num : nums) {
   
			if (num <= third || num == second || num == first) continue;
			if (num > first) {
   
				third = second;
				second = first;
				first = num;
			} else if (num > second) {
   
				third = second;
				second = num;
			} else if (num > third) {
   
				third = num;
			}
		}
		return (int) (third == Long.MIN_VALUE ? first : third);
	}

628. 三个数的最大乘积
     

// 思路: 这3个数的情况有3种
1. 3个数全是正数, 取最大的3个正数
2. 3个数全是负数, 取最大的3个负数
3. 3个数中2个正数,1个负数, 正数选最大,负数选最小, 还是数组中最大3个数
4. 3个数中1个正数,2个负数, 最大两个负数和最大的正数

第1种情况与2 3 4种情况比较,即可得出最大

public int maximumProduct(int[] nums) {
   
		Arrays.sort(nums);
		int length = nums.length;
		int max = nums[length - 1] * nums[length - 2] * nums[length - 3];
		max = Math.max(max, nums[0] * nums[1] * nums[length - 1]);
		return max;
	}

统计数组中的元素 645、697、448、442、41、274

645. 错误的集合

 思路: 出现两次的是第一个答案
		1到n中不存在的是第二个答案
public int[] findErrorNums(int[] nums) {
   
		Map<Integer, Integer> map = new HashMap<>();
		for (int nm : nums) {
   
			map.put(nm, map.getOrDefault(nm, 0) + 1);
		}
		int[] result = new int[2];
		for (int i = 1; i <= nums.length; i++) {
   
			if (map.containsKey(i)) {
    
				if (map.get(i) == 2) {
   
				    result[0] = i;
                }
			} else {
   
				result[1] = i;
			}
		}
		return result;
	}

697. 数组的度

思路: 计算次数最多的元素范围
	 如果多个次数相同,那就取最大的
public int findShortestSubArray(int[] nums) {
   
        Map<Integer, int[]> map = new HashMap<Integer, int[]>();
        int n = nums.length;
        for (int i = 0; i < n; i++) {
   
            if (map.containsKey(nums[i])) {
   
                // [0]是计算次数, [1]起始点, [2]结束点
                map.get(nums[i])[0]++;
                map.get(nums[i])[2] = i;
            } else {
   
                map.put(nums[i], new int[]{
   1, i, i});
            }
        }
        int maxNum = 0, minLen = 0;
        for (Map.Entry<Integer, int[]> entry : map.entrySet()) {
   
            int[] arr = entry.getValue();
            if (maxNum < arr[0]) {
   
                maxNum = arr[0];
                minLen = arr[2] - arr[1] + 1;
            } else if (maxNum == arr[0]) {
   
                if (minLen > arr[2] - arr[1] + 1) {
   
                    minLen = arr[2] - arr[1] + 1;
                }
            }