写在前面

最近经常觉得自己越来越笨，一些很简单的问题愣是想不出来。今天去leetcode上做了几道题，面对上学时不止一次刷过的题目竟然有的连最笨的方法都想不出来。感觉还是要经常用用脑子，不然真的会生锈。。。
算法对我目前的工作确实用不到，而且一些基础常用的基本各个语言都有实现，专业算法更是各种现成的工具包。但真遇到问题时就算用别人的方法，自己起码也要做到理解到位吧。所以贵在坚持积累，从基础拾起😁。

目的

解题不是目的，重要的是通过做一道题目帮助自己get到哪些东西。我总结了以下几点：

• 数据结构。 定义合理的数据结构很重要。比如今天下面遇到的问题无非都是哈希表的使用、双指针、数组的奇偶等。对复杂的问题这点就更为明显。
• 时间复杂度。 有时会发现一个笨方法也能通过，但不能做完拉倒，想想问题理论上最优的时间复杂度是多少，自己有没更优的方法。之后再去查阅其他人的解答，理解消化。
• 知识点。 毕业后还给老师的知识，有些很基础的自以为早学透的东西，真正自己动手去写发现还是有很多地方没理解到位、没掌握好的。
• 代码风格。 有时候业务逻辑写多了，明明有更简洁还易读的方式却还是写一堆冗长的代码，在阅读别人代码时多思考。

1.两数之和

给定一个整数数组和一个目标值，找出数组中和为目标值的两个数。你可以假设每个输入只对应一种答案，且同样的元素不能被重复利用。
示例:
给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]

这个我是想都没想就两层遍历提交通过，也没想过是不是有更好的方法。后来做到别的题目才想到，这种简单问题两层遍历O(n^2)是很高的时间复杂度了，写的时候就该下意识的思考下，一般都有更优的方法。笨方法就不贴了，理论上一次遍历就可以找到，借助哈希表O(1)的查找实现：

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

2.两数相加

给定两个非空链表来表示两个非负整数。位数按照逆序方式存储，它们的每个节点只存储单个数字。将两数相加返回一个新的链表。
你可以假设除了数字 0 之外，这两个数字都不会以零开头。
示例：
输入：(2 -> 4 -> 3) + (5 -> 6 -> 4)
输出：7 -> 0 -> 8
原因：342 + 465 = 807

这道题确实在面试中被问过，好在还能写得出来，主要是注意细节：两数不等长、后面的进位等，问题在于之前说过的代码太过冗长，我当时这么写的：

class ListNode {
    int val;
    ListNode next;
    ListNode(int x) { val = x; }
}

class Solution {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        ListNode result = new ListNode(0);
        ListNode p1=l1,p2=l2,pr=result;
        int sum=0,carry=0;

        while(p1!=null && p2!=null){
            sum = (p1.val+p2.val+carry)%10;
            carry = (p1.val+p2.val+carry)/10;

            pr.next = new ListNode(sum);
            pr = pr.next;
            p1 = p1.next;
            p2 = p2.next;
        }

        while (p1!=null){
            sum = (p1.val+carry)%10;
            carry = (p1.val+carry)/10;

            pr.next = new ListNode(sum);
            pr = pr.next;
            p1 = p1.next;
        }

        while (p2!=null){
            sum = (p2.val+carry)%10;
            carry = (p2.val+carry)/10;

            pr.next = new ListNode(sum);
            pr = pr.next;
            p2 = p2.next;
        }

        if (carry != 0)
            pr.next = new ListNode(carry);

        return result.next;
    }
}

思路还算清楚，但这代码着实看着不舒服。对比找了网上的解答来看，其实这个结果链表往前加的来源就三个：两个加数和进位，只要存在其中一个循环就继续，这样写起来就简洁多了：

class ListNode {
    int val;
    ListNode next;
    ListNode(int x) { val = x; }
}

class Solution {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        ListNode result = new ListNode(0);
        ListNode p1=l1,p2=l2,pr=result;
        int carry=0;
        while(p1 != null || p2 != null || carry != 0){
            int sum = ((p1 == null) ? 0 : p1.val) + ((p2 == null) ? 0 : p2.val) + carry;
            carry = sum/10;
            pr.next = new ListNode(sum%10);
            pr = pr.next;
            if(p1 != null) p1 = p1.next;
            if(p2 != null) p2 = p2.next;
        }
        return result.next;
    }
}

3.无重复字符的最长子串

给定一个字符串，找出不含有重复字符的最长子串的长度。
示例：给定 “abcabcbb” ，没有重复字符的最长子串是 “abc” ，那么长度就是3。
给定 “bbbbb” ，最长的子串就是 “b” ，长度是1。
给定 “pwwkew” ，最长子串是 “wke” ，长度是3。请注意答案必须是一个子串，”pwke” 是 子序列 而不是子串。

这个做的时候没想出来，但总的写一下在去查答案。。最笨的穷举总是可以试试的，两层遍历以每个字符为起点，还得通过string的contains方法做判断，竟然还超过了4%的java提交记录。。。只能说这个网站对运行时间测的不准吧，算上contains方法这个时间复杂度高得吓人了，肯定是超时的。
写的过程竟还错了好多细节，瞬间感觉自己菜的一匹：

class Solution {
    public int lengthOfLongestSubstring(String s) {
        int length = s.length();
        if(length == 0 || length == 1) return length;
        int result = 1;
        for(int i=0; i<= length-result ;i++){
            // 这里一开始写的 for(int j=i+result ...) ，以当前result为基准查找，有
            // 点想当然了，中间也可能有重复的。
            for(int j=i+1;j<length;j++)  
            {
                if(!s.substring(i,j).contains(s.substring(j,j+1)))
                {
                    if (result < j-i+1) result = j-i+1;
                }
                else
                {
                    break;
                }

            }
        }
        return result;
    }
}

这么垃圾的方法还一再运行不过，确实有点受打击。但仔细想想，这道题在学校校招那会肯定做过不止一次，和第一题一样，利用哈希表存下标，只是一时没想起来（这么安慰下自己吧）
思路就是两个指针，一个用来遍历，一个记录当前字符前一次出现的下标pre，这个下标信息可以用一个HashMap记录，只要当前字符在pre之后出现过，就将pre移动到出现的位置之后(因为这之间的子串都包含当前字符的重复，而子串不会是最长的)：

class Solution {
    public int lengthOfLongestSubstring(String s) {
        int result = 0;
        HashMap<Character,Integer> preIdx = new HashMap<>();
        for (int i=0, pre=0, length=s.length();i<length;i++) {
            Integer p = preIdx.get(s.charAt(i));
            if (p != null && p >= pre){
                pre = p + 1;
            }
            result = Math.max(result,i-pre+1);
            preIdx.put(s.charAt(i),i);
        }
        return result;
    }
}

总结一下：

• 1和3都没有一次找到最优方案，这两个类似，都是用map存储下标，因为查找起来复杂度为O(1)；
• 2是代码冗余，遇到问题不要上来就写循环，先理清楚思路，想想出入口；
• 不要想当然，确保正确性，细节问题、临界点等要先想好；
• 遇到看都看不懂的，说明有模糊的知识点需要好好梳理了