leetcode题集第0周 题号#1

前言

我从两周前开始接触算法，从一周前开始接触leetcode。我主要使用leetcode练习算法题目，本没有记录一番的打算，正巧加入了耗子叔的左耳听风 ARTS专栏，其中的A就是每周一道leetcode算法题，并且需要记录下来分享，于是开始了leetcode做题记录的第一篇。

在文章中我不会只是简单记录答案，我会写下自己解题思路的变化，同时也会对复杂的代码处进行解释，因为刚开始接触算法题目，所以从easy级别的开始，有复杂代码的可能性比较低，接下来直接上题目。

题目 两数之和 题号#1

给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那两个 整数，并返回他们的数组下标。

你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。

示例:

给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]

解题思路

读懂题目的第一思路就是利用两个循环对数组的元素进行加和，与target比对判断，成功就返回数组两个元素下标，代码如下：

class Solution {
    public int[] twoSum(int[] nums, int target) {
        int i = 0, j = i + 1;
        for(; i < nums.length - 1; i++) {
            for(j = i + 1; j < nums.length; j++) {
                if(nums[j] + nums[i] == target) {
                    return new int[] {i, j};
                }
            }
        }
        
        return null;
    }
}

这段代码时间复杂度是O(n²)，应该还有更优的解。转换思路，其实结果是返回满足条件的元素下标，元素与下标需要关联上，又可以快速通过元素返回下标的方式让我想到了Map。代码如下：

class Solution {
    public int[] twoSum(int[] nums, int target) {
        Map<Integer, Integer> map = new HashMap<>(nums.length);
        for(int i = 0; i < nums.length && nums[i] <= target; i++) {
            map.put(nums[i], i);
        }

        for(Map.Entry<Integer, Integer> entry : map.entrySet()) {
            Integer index = map.get(target - entry.getKey());
            if(index != null) {
                return new int[] {entry.getValue(), index};
            }
        }
        return null;
    }
}

满心欢喜以为找到了O(n)时间复杂度的解法，结果这个提交失败，失败示例如下

输入：
[3,3]
6
输出：
[1,1]
预期：
[0,1]

究其原因，数组中的元素重复，Map中的key产生覆盖，而又使用Map进行遍历，无法遍历到数组所有元素，并且未判断是否重复使用一个数组元素进行加和满足条件，导致出现此问题。于是继续改进代码：

class Solution {
    public int[] twoSum(int[] nums, int target) {
        Map<Integer, Integer> map = new HashMap<>(nums.length / 3);
        for(int i = 0; i < nums.length && nums[i] <= target; i++) {
            map.put(nums[i], i);
        }

        for(int i = 0; i < nums.length; i++) {
            int otherNum = target - nums[i];
            if(map.containsKey(otherNum) && map.get(otherNum) != i) {
                return new int[] {i, map.get(otherNum)};
            }
        }

        return null;
    }
}

将遍历map修改为遍历数组本身，虽然还是会有数组元素重复导致key覆盖，但是只要能找出一对满足加和为target条件的元素下标即可，所以map的key因重复数组元素导致覆盖也就不影响结果，并且在第10行代码上加入了对是否重复使用一个数组元素进行加和的判断。其实，这段代码也失败了，失败样例如下：

输入：
[-1,-2,-3,-4,-5]
-8
输出：
[0,0]
预期：
[2,4]

原因是第4行代码处增加了nums[i] <= target的判断，我认为相加之和等于target的两数必然小于或等于target，想利用些条件减少map中的数据量，却忽略了负数的可能性。根据问题修改代码：

class Solution {
    public int[] twoSum(int[] nums, int target) {
        Map<Integer, Integer> map = new HashMap<>(nums.length / 3);
        for(int i = 0; i < nums.length; i++) {
            map.put(nums[i], i);
        }

        for(int i = 0; i < nums.length; i++) {
            int otherNum = target - nums[i];
            if(map.containsKey(otherNum) && map.get(otherNum) != i) {
                return new int[] {i, map.get(otherNum)};
            }
        }

        return null;
    }
}

这段代码可以成功通过所有测试样例，而且时间也比双循环时提高了许多。

根据官方还有一个更优的解，就是在循环的同时对map进行判断，不满足条件便放入map，满足条件就返回结果。代码如下：

class Solution {
    public int[] twoSum(int[] nums, int target) {
        Map<Integer, Integer> map = new HashMap<>(nums.length / 3);
        for(int i = 0; i < nums.length; i++) {
            int otherNum = target - nums[i];
            if(map.containsKey(otherNum)) {
                return new int[] {map.get(otherNum), i};
            }
            map.put(nums[i], i);
        }

        return null;
    }
}

通过几天的解题发现自己对题目样例中可能出现的特殊情况缺少考虑，对操作的简化也还需要更深入的思考。