刷了力扣题之后，我也变的一发不可收拾了？

51 阅读 0 评论 34 点赞

我是靠谱客的博主糟糕自行车，最近开发中收集的这篇文章主要介绍刷了力扣题之后，我也变的一发不可收拾了？，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

作为程序员界的一枚小菜鸟，可谓是，从大量的 CRUD 业务中，练就了一身复制粘贴即可用的本领。

因为大家不是都说：程序 = 复制 + 百度吗，再高级一点的就是复制 + 谷歌喽。（我不禁想，难道科学^上网就高级了？）

反正都是拿来主义嘛，代码能跑起来就完事，实在不行，删库跑路也很轻松呀 ^_^。

但是呢，迫于网上不断流出的 “35岁程序员危机” 话题，我不得不开始认真思考，我这马上奔三的大龄青年，离 35 岁还差多远呢。

再加上，身边大佬朋友都在说算法的重要性，看来，我真的需要重新考虑“程序”的定义了。看下边严肃版的官方定义。。。

程序 = 算法 + 数据结构

于是乎，我也开始重视算法和数据结构的重要性了。那些躺在网盘里的收藏版，也是时候拿出来晒一晒了。

但是，只看理论，不做题，那不是耍流氓吗。好歹我也是一正经，正直的好青年，不能辜负力扣（LeetCode）对广大适龄程序员的好心啊。

万丈高楼平地起，我总得先去申请个账号吧（话说，貌似我之前好像申请过？但是都忘得一干二净了）。怎么个刷题法呢，又犯难了，好在我有百度啊，谷歌啊（咳咳，说好的不用搜索引擎呢）。

这时，查出来在某乎上看到一句特别有意思的话，说是有哥们从“两数之和”开始算法之路，从此变的一发不可收拾。当上总经理，出任CEO，迎娶富婆哦不白富美，走上人生巅峰。

我哩乖乖，有这么神奇么。我都不信了，我也在首页上看到了那个特别闪亮的四个大字“两数之和”，怎么一点儿点击欲都没有呢。

为了亲自感受这个变化过程，我决定一探究竟。这不看不要紧，一看之后，我也变得一发不可收拾了，我竟然隐隐的感觉，哟呵，这个题还挺有意思？！

原题如下：

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

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

示例:

给定 nums = [2, 7, 11, 15], target = 9

因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]

看到这个题目，可能很多人就会说，这有何难，哐哐一顿敲，两个for循环不就搞定了吗。看我的解法。（我把 target 设为了 13）

public class SumTest {
    public static void main(String[] args) {
        int[] arr =  {2, 7, 11, 15};

        int[] result = sumTwo(arr , 13);
        System.out.println(Arrays.toString(result));

    }

    private static int[] sumTwo(int[] nums, int target) {
        for (int i = 0; i < nums.length - 1; i++) {
            for (int j = i + 1; j < nums.length; j++) {
                if(nums[i] + nums[j] == target){
                    return new int[]{i,j};
                }
            }
        }
        return null;
    }

}

思想就是，外层循环从数组第一个元素开始遍历，把循环变量记为 i，那么内层循环 j 从 i+1 就可以了。最后判断两个元素之和等于目标值，不就得出相应的数组下标了吗。

这样算是没错，但是没有考虑时间复杂度。我们知道两层循环的叠加，会使时间复杂度变为 O（n ^ 2），数据量小的情况下不明显，数据量大了之后，执行效率就会直线下降（哦不，应该是平方阶下降）。

我实在也想不出来什么好办法了。好在，力扣有讨论区，还有解法区，可以围观各路大神的解题思路，还有官方的解法。

果然，发现了更牛逼的算法。且看，

private static int[] sumTwo(int[] nums, int target) {

    HashMap<Integer, Integer> map = new HashMap<>();

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

        map.put(nums[i],i);
    }
    return null;
}

以上的时间复杂度直接变为 O（n）。什么思路呢。就是利用哈希表，把数组中的元素和它的下标对应起来作为 kv 对。循环时，把他们依次放入 hashMap中。然后判断，map中是否存在 “目标值减去当前key值”这样的一个 key，存在就返回。

什么意思呢，举个例子，比如我存到 map里一个 key 是 “2”，那我只要找到一个key 是（13 - 2 = 11）的这样一个 key，不就正好说明他们的和是 13 嘛。这两个数不就是我要找的数吗，把他们的下标返回就可以了。

这个思路真的是很神奇，我在心中惊呼，真的是骚操作，只有你想不到，没有大神做不到。

我们看一下用这种方法，程序步骤是怎么走的。（以和为 13 为例）

数组: [ 2 , 7 , 11 , 15]  , target = 13

step1:
key = 2，value = 0，
13 - 2 = 11 ，不存在这个key，就把 (2,0) 放入map中

step2:
key = 7，value = 1,
13 - 7 = 6，不存在这个key，就把 (7,1) 放入map中

step3:
key = 11, value = 2,
13 - 11 = 2 ，可以发现map中已经存在 2 这个key了。
因此，就把 2的下标 0 和 11 的下标 2 返回。

是不是很神奇，首先这个代码看起来就比上边的双层循环要高大上许多。其次，时间复杂度也从原来的 O（n^2），变成了 O（n）。

我仿佛打开了算法的一扇神奇之门（不要笑我，轻喷）。于是，顺便把每日 1 题也给做了，拿到 10 个积分，美滋滋。

打卡第一天，希望自己能坚持下去！

开始一件事容易，但是坚持一件事，很难。坚持下去，你就超越了很多人了，共勉！

如果本文对你有用，欢迎点赞，评论，转发。

学习是枯燥的，也是有趣的。我是「烟雨星空」，欢迎关注，可第一时间接收文章推送。