算法之路-两数之和

---

前言

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。
你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。你可以按任意顺序返回答案。

一、暴力搜索

算法描述：

两个循环，第一个循环从前到后取出一个数nums[i]，第二个循环寻找num[j]，num[i]+num[j] = target 。

时空复杂度：

时间复杂度为O(n^2)。不考虑原数组的情况下，空间复杂度为O(1)。

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

二、Hash表1

算法描述

将原数组元素值(key)和其下标(value)存入一张哈希表后，用一个循环遍历nums，以O(1)时间复杂度在哈希表中寻找map.containsKey(target - nums[i])。

时空复杂度

将原数组存入哈希表花费O(n)时间，循环遍历花费O(n)时间，哈希表每次定位只花费O(1)时间，所以时间复杂度为O(n)。
哈希表消耗空间为O(n)，所以空间复杂度为O(n)。

class Solution {
    public int[] twoSum(int[] nums, int target) {
        
        HashMap<Integer,Integer> map = new HashMap<>();
        for(int i = 0; i<nums.length; i++){
            map.put(nums[i],i);
        }
        for(int j = 0; j < nums.length; j++){
            int num = target - nums[j];
            if(map.containsKey(num) && map.get(num) != j){
                return new int[]{j, map.get(num)};
            }
        }
        return  null;
    }
}

三、Hash表2

算法描述

在哈希表1算法中，拷贝了完整的原数组到哈希表中，在哈希表中查找target - nums[i]时，会基于完整的数据查找。可以不直接拷贝原数组到哈希表中，而是在遍历nums查找哈希表时，找不到再put(K,V)，找到则立即返回结果。采用这样的方式能够节省哈希表的空间，且减少空间的同时也削减了计算哈希值的耗时。

时空复杂度

时间复杂度取决于遍历原数组耗时，为O(n)。使用了哈希表存储数组内容，空间复杂度O(n)。

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

---

总结

从上述解题过程和分析可以看出，对于算法上一些边角优化并不能从根本上降低该解法的时间复杂度和空间复杂度，反而提升了该解法的理解复杂度和 coding 复杂度。

因此，我对自己的要求是能够想到暴力解法，然后通过时间空间的操作把整体复杂度降低一个数量级。