LeetCode热题100道-day01

1. 两数之和

创建一个哈希表，对于每一个数(x)，我们先查询哈希表中是否存在target-x，然后将x插入到哈希表中，即可保证x不会和自己匹配

class Solution {  
    public static int[] twoSum(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 new int[]{};  
    }  
}

2. 两数相加

leetcode.cn/problems/ad…

定义一个虚拟头节点和一个指向头节点的遍历指针，同时遍历l1和l2，遇到null补0，将遍历得到的结果(x，y)与上一次得到的进位(carry)相加得到sum，sum/10得到进位，sum%10得到新节点的值，之后创建一个新节点，遍历指针指向下一个节点。最后如果还有进位，就新增一个节点保存

class Solution {  
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {  
        // 定义虚拟头节点和指针  
        ListNode pre = new ListNode(0);  
        ListNode cur = pre;  
        int carry = 0; // 是否进位  
        // 终止条件是l1和l2等于都null  
        while (l1 != null || l2 != null) {  
            int x = l1 == null ? 0 : l1.val;  
            int y = l2 == null ? 0 : l2.val;  
            int sum = x + y + carry; // 相加  
            carry = sum / 10; // 是否进位  
            sum = sum % 10; // 这个位置具体的值  
            cur.next = new ListNode(sum); // 得到当前位并且组装节点
            cur = cur.next; // 将指针移动到下一位  
            if (l1 != null) {  
                l1 = l1.next;  
            }  
            if (l2 != null) {  
                l2 = l2.next;  
            }  
        }  
        // 最后两数相加完还有进位，进位呗  
        if (carry == 1) {  
            cur.next = new ListNode(carry);  
        }  
        return pre.next;  
    }  
}

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

leetcode.cn/problems/lo…

首先，判断当前字符是否包含在map中，如果不包含，将该字符添加到map（字符，字符在数组下标）,此时没有出现重复的字符，左指针不需要变化。此时不重复子串的长度为：end-start+1，与原来的maxLen比较，取最大值；
如果当前字符 ch 包含在 map中，此时有2类情况：
1. 当前字符包含在当前有效的子段中，如：abca，当我们遍历到第二个a，当前有效最长子段是 abc，我们又遍历到a，那么此时更新 left 为 map.get(a)+1=1，当前有效子段更新为 bca；
2. 当前字符不包含在当前最长有效子段中，如：abba，我们先添加a,b进map，此时left=0，我们再添加b，发现map中包含b，而且b包含在最长有效子段中，就是1）的情况，我们更新 left=map.get(b)+1=2，此时子段更新为 b，而且map中仍然包含a，map.get(a)=0；随后，我们遍历到a，发现a包含在map中，且map.get(a)=0，如果我们像1）一样处理，就会发现 left=map.get(a)+1=1，实际上，left此时应该不变，left始终为2，子段变成 ba才对。
为了处理以上2类情况，我们每次更新left，left=Math.max(left , map.get(ch)+1)。另外，更新left后，不管原来的 s.charAt(i) 是否在最长子段中，我们都要将 s.charAt(i) 的位置更新为当前的i，因此此时新的 s.charAt(i) 已经进入到当前最长的子段中！

public int lengthOfLongestSubstring(String s) {  
    HashMap<Character, Integer> map = new HashMap<>();  
    int maxLen = 0;  
    for (int start = 0, end = 0; end < s.length(); end++) {  
        char c = s.charAt(end);  
        if (map.containsKey(c)) {  
            start = Math.max(map.get(c), start);  
        }  
        maxLen = Math.max(end - start + 1, maxLen);  
        map.put(c, end + 1);  
    }  
    return maxLen;  
}

5. 最长回文子串

leetcode.cn/problems/lo…

暴力解法

class Solution {  
    // 暴力解法  
    public String longestPalindrome(String s) {  
        int n = s.length();  
        if (n < 2) {  
            return s;  
        }  
        int maxLen = 1;  
        int begin = 0;  
        char[] charArray = s.toCharArray();  
        // 枚举所有长度严格大于1的子串，charArray[i..j]  
        for (int i = 0; i < n - 1; i++) {  
            for (int j = i + 1; j < n; j++) {  
                if (j - i + 1 > maxLen && validPalindromic(charArray, i, j)) {  
                    maxLen = j - i + 1;  
                    begin = i;  
                }  
  
            }  
        }  
        return s.substring(begin, begin + maxLen);  
    }  
    // 判断是不是回文串  
    private boolean validPalindromic(char[] charArray, int left, int right) {  
        while (left < right) {  
            if (charArray[left] != charArray[right]) {  
                return false;  
            }  
            left++;  
            right--;  
        }  
        return true;  
    }  
}