重视算法，提升性能

重视算法

在日常写代码的时候，常常就想着跑代码，修复bug，尽快实现需求，完成任务。又有多少时候在想着优化算法、提升性能呢？若有时间好好地优化算法，可以锻炼自己的思维，降低迭代的难度。

从力扣上第一道简单的算法题开始。

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

示例 1：
输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。

示例 2：
输入：nums = [3,2,4], target = 6
输出：[1,2]

示例 3：
输入：nums = [3,3], target = 6
输出：[0,1]

提示：
2 <= nums.length <= 10^4
-10^9 <= nums[i] <= 10^9
-10^9 <= target <= 10^9
只会存在一个有效答案。
进阶：你可以想出一个时间复杂度小于 O(n2) 的算法吗？

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/two-sum
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

1、暴力解法（双层for循环）

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

提交结果	执行用时	内存消耗	语言
通过	50 ms	37.8 MB	Java

2、拒绝嵌套for循环（引入HashMap）

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

提交结果	执行用时	内存消耗	语言
通过	4 ms	39.2 MB	Java

3、减少遍历次数

然后看了一下其他人写的用时最少的算法，看来自己在平时还是缺少优化算法的意识。

class Solution {
    public int[] twoSum(int[] nums, int target) {
        if(nums == null || nums.length<2){
            return new int[]{};
        }
        Map<Integer,Integer> map = new HashMap<>();
        int leftPoint = 0;
        int rightPoint = nums.length-1;
        while(leftPoint<=rightPoint){
            int ln0 = nums[leftPoint];
            int rn0 = nums[rightPoint];
            int ln1 = target - ln0;
            int rn1 = target - rn0;
            if(map.containsKey(ln1)){
                return new int[]{leftPoint,map.get(ln1)};
            }else {
                map.put(ln0,leftPoint++);
            }
            if(map.containsKey(rn1)){
                return new int[]{rightPoint,map.get(rn1)};
            }else {
                map.put(rn0,rightPoint--);
            }
        }
        return new int[]{};
    }
}

提交结果	执行用时	内存消耗	语言
通过	0 ms	38.6 MB	Java

4、小结

从上面一个小小的例子，可以稍微感受一下算法的威力。所以在日常写代码实现需求的时候，若有时间就好好优化一下算法吧，不要就是一句“能跑就行！”。