【java】leetcode刷题记录+简单思路（hot100+剑指offer 简单\中等难度）

避免重复刷题每次都两眼一抹黑咩都不记得，简单记一下思路。大概每天*10的进度。

1. 两数之和（简单）

题目：

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

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

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

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

思路：哈希表
遍历数组，若此时哈希表中有有当前元素的另一半，直接返回；
若没有，将当前元素存入哈希表。
其中哈希表的结构，以数组元素为索引（因为是不重复的），数组元素对应的下标作值。

注意要求返回的是数组的下标，不然Hashset就行。

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

2. 两数相加（中等）

题目：给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。
请你将两个数相加，并以相同形式返回一个表示和的链表。
你可以假设除了数字 0 之外，这两个数都不会以 0 开头。

输入：l1 = [2,4,3], l2 = [5,6,4]
输出：[7,0,8]
解释：342 + 465 = 807.

输入：l1 = [0], l2 = [0]
输出：[0]

输入：l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]
输出：[8,9,9,9,0,0,0,1]

思路：
就是链表遍历吧，注意一下进位和链表长度不等时多出来的部分。
流程就是遍历两个链表，注意记录进位，然后当一个链表指针指向空时，作为零值计算。
一些注意点见注释。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        ListNode p = new ListNode(0);   //指向头结点
        ListNode q = p;     //遍历结果链表的指针
        int m = 0;  //进位
        while (l1 != null || l2 != null || m != 0){     //这里容易忘记链表遍历完但是还有进位的情况
            int l1_nunm = l1 != null ? l1.val : 0;
            int l2_nunm = l2 != null ? l2.val : 0;
            int sum = l1_nunm + l2_nunm + m;
            m = sum / 10;
            sum = sum % 10;

            ListNode s = new ListNode(sum);
            q.next = s;
            q = q.next;

            //这里注意判断条件是l1!=null而不是l1.next，因为必须到指向null，作为零值
            if(l1 != null) l1 = l1.next;
            if(l2 != null) l2 = l2.next;
        }
        return p.next;
    }
}

3. 无重复字符的最长子串（中等）

题目：给定一个字符串 s ，请你找出其中不含有重复字符的 最长子串 的长度。

输入: s = "abcabcbb"
输出: 3 
解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。

输入: s = "bbbbb"
输出: 1
解释: 因为无重复字符的最长子串是 "b"，所以其长度为 1。

输入: s = "pwwkew"
输出: 3
解释: 因为无重复字符的最长子串是 "wke"，所以其长度为 3。
     请注意，你的答案必须是 子串 的长度，"pwke" 是一个子序列，不是子串。

输入: s = ""
输出: 0

思路：滑动窗口
遍历元素，当前元素已出现时，可能需要移动左边界。
至于为什么是可能，因为元素是以hashmap存储的，在此过程中map里不删，所以有可能遍历到的元素是在left边界之前出现过的，并不影响当前在计算的子串。设查找到的已存在元素位于j处。
因此需要判断，这个已经在map里的元素是不是比left小，若该重复元素确实在边界以内，则需要移动边界至j+1，并将该元素的位置更新为i，保证子串内只有一个这个元素。
长度的计算通过i和left就行。

class Solution {
    public int lengthOfLongestSubstring(String s) {
        HashMap<Character,Integer> hash = new HashMap<>();
        int max = 0;
        int left = 0;
        for(int i = 0;i < s.length();i++){
            if(hash.containsKey(s.charAt(i))){  //已经出现过
                left = Math.max(left, hash.get(s.charAt(i)) + 1);
            }
            hash.put(s.charAt(i),i);
            max = Math.max(max, i - left + 1);
        }
        return max;
    }
}

4. 寻找两个正序数组的中位数（困难）

之前做的，这一次先不看困难的，回头再说

class Solution {
    public double findMedianSortedArrays(int[] nums1, int[] nums2) {
        int p = 0;
        int q = 0;
        boolean flag = true;
        double x = 0,y = 0;
        if ((nums1.length + nums2.length)%2 == 0)
            flag = false;
        int m = (nums1.length + nums2.length)/2;
        for(int i = 0;i <= m ;i++){
            x = y;
            if(p == nums1.length)
                y = nums2[q++];
            else if (q == nums2.length)
                y = nums1[p++];
            else if(nums1[p] <= nums2[q])
                y = nums1[p++];
            else
                y = nums2[q++];
        }
        if(!flag)
            x = (x + y)/2;
        else
            x = y;
        return x;
    }
}

5. 最长回文子串（中等）

题目：给你一个字符串 s，找到 s 中最长的回文子串。

输入：s = "babad"
输出："bab"
解释："aba" 同样是符合题意的答案。

输入：s = "cbbd"
输出："bb"

输入：s = "a"
输出："a"

输入：s = "ac"
输出："a"

思路：
回文，即正反序相同。
中心扩散法。即以中心位置向两边发散，直至找到最大长度。
先向左找和中心元素一样的，再向右找和中心元素一样的，再同时向两边扩展。

不是最优解法，只是比较好理解。

class Solution {
    public String longestPalindrome(String s) {
        if(s.isEmpty() || s.length() < 2){
            return s;
        }
        int left_max = 0;
        int right_max = 0;
        int len_max = 1;

        boolean[][] dp = new boolean[s.length()][s.length()];

        for (int i = 1; i < s.length(); i++){
            int left = i - 1;
            int right = i + 1;
            int len = 1;
            while (left >= 0 && s.charAt(left) == s.charAt(i)){
                left--;
                len++;
            }
            while (right <= s.length() - 1 && s.charAt(right) == s.charAt(i)){
                right++;
                len++;
            }
            while (left >= 0 && right <= s.length() - 1 && s.charAt(left) == s.charAt(right)){
                left--;
                right++;
                len += 2;
            }
            if(len > len_max){
                left_max = left;
                len_max = len;
            }
        }
        return s.substring(left_max + 1,left_max + len_max + 1);
    }
}

10. 正则表达式匹配（困难）

暂略

11. 盛最多水的容器（中等）

题目：给你 n 个非负整数 a1，a2，...，an，每个数代表坐标中的一个点 (i, ai) 。在坐标内画 n 条垂直线，垂直线 i 的两个端点分别为 (i, ai) 和 (i, 0) 。找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。
说明：你不能倾斜容器。

输入：[1,8,6,2,5,4,8,3,7]
输出：49 
解释：图中垂直线代表输入数组 [1,8,6,2,5,4,8,3,7]。在此情况下，容器能够容纳水（表示为蓝色部分）的最大值为 49。

 之前做过一次。
思路大概是不断收缩长度，并且向短板的那边收缩。

应该不是最优。

class Solution {
    public int maxArea(int[] height) {
        int left = 0;
        int right = height.length - 1;
        int max_v = 0;

        while (left < right){
            int v = Math.min(height[left],height[right]) * (right - left);
            max_v = v > max_v ? v : max_v;
            if(height[left] < height[right])  //左边界是短板
                left++;
            else
                right--;
        }
        return max_v;
    }
}

15. 三数之和（中等）

题目：给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有和为 0 且不重复的三元组。
注意：答案中不可以包含重复的三元组。

输入：nums = [-1,0,1,2,-1,-4]
输出：[[-1,-1,2],[-1,0,1]]

思路：排序，遍历数组，配合双指针，双指针分别指向剩余数组的左右边界
若和为0 ，返回；
若和小于0，是左边界太小了，左边界++；
若和大于0，是右边界太大了，右边界--。
注意由于要找的是不重复的，所以遍历的元素不能和上一个相同，找到一组之后要把左右边界都移动到元素不重复的位置。

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        List res = new ArrayList();
        Arrays.sort(nums);
        for(int i = 0;i < nums.length - 1;i++){
            if(i > 0 && nums[i] == nums[i - 1])     continue;
            int left = i + 1;
            int right = nums.length - 1;
            while (left < right){
                int sum = nums[i] + nums[left] + nums[right];
                if(sum == 0){   //找到了
                    List<Integer> list = new ArrayList();
                    list.add(nums[i]);
                    list.add(nums[left]);
                    list.add(nums[right]);
                    res.add(list);
                    
                    //注意以下，要跳过重复的元素
                    while (left < right && nums[left] == nums[left+1])  left++;
                    while (left < right && nums[right] == nums[right - 1])  right--;
                    
                    //然后这个重复的其实已经计算过了，下一个
                    left++;
                    right--;
                }
                else if(sum < 0)   //左边界值太小
                    left++;
                else               //右边界值太大
                    right--;

            }
        }
        return res;
    }
}

17. 电话号码的字母组合（中等）

题目：
给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。答案可以按 任意顺序 返回。
给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。

 输入：digits = "23"
输出：["ad","ae","af","bd","be","bf","cd","ce","cf"]

 思路：排列组合问题，递归。

解法不太优。

class Solution {
    private String[] nummap = {
            " ",    //0
            "",     //1
            "abc",  //2
            "def",  //3
            "ghi",  //4
            "jkl",  //5
            "mno",  //6
            "pqrs", //7
            "tuv",  //8
            "wxyz"  //9
    };
    private ArrayList<String> res;
    public List<String> letterCombinations(String digits) {
        res = new ArrayList<String>();
        if(digits.isEmpty())    return res;
        findCombination(digits,0,"");   //index标记找到digits哪一位了，s是当前的结果序列
        return res;
    }
    private void findCombination(String digits, int index, String s){
        if(index == digits.length()){   //根据index判断是否找完digits了，若找完，s就是这次的结果
            res.add(s);
            return;
        }
        String code = nummap[digits.charAt(index) - '0'];   //取出本次要处理的字母
        for(int i = 0;i < code.length();i++){
            findCombination(digits, index + 1, s + code.charAt(i)); //把当前字母加进去，找下一位数字
        }
    }
}

19. 删除链表的倒数第 N 个结点（中等）

题目：给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。
进阶：你能尝试使用一趟扫描实现吗？

输入：head = [1,2,3,4,5], n = 2
输出：[1,2,3,5]

思路：快慢指针。
两个指针之间相差n，快指针遍历完的时候，慢指针走到倒数第n个结点，即p指向最后一个结点时，q指向要删结点的上一个。

注意一下如果要删的点就是第一个结点的话，q指向的不是要删的上一个结点，需要直接操作head

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode p = head;  //快
        ListNode q = p;     //慢
        //让快指针先跑n
        for(int i = 0;i < n;i++){
            p = p.next;
        }
        //p跑完了，开始一起跑
        if(p == null)  //不用跑了，要删的就是第一个元素
            return head.next;
        while (p.next != null){
            p = p.next;
            q = q.next;
        }
        p = q.next.next;
        q.next.next = null;
        q.next = p;
        return head;
    }
}

21. 合并两个有序链表（简单）

题目：将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 

输入：l1 = [1,2,4], l2 = [1,3,4]
输出：[1,1,2,3,4,4]

思路：递归
终止条件：当两个链表都为空。
如何递归：判断 l1 和 l2 头结点哪个更小，然后较小结点的 next 指针指向其余结点的合并结果，返回这个较小的结点给上一层进行连接。

注意一个为空了之后要返回另一个链表继续递归，直至两个链表都为空。

class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        if(l1 == null)  return l2;
        else if(l2 == null)     return l1;
        else if(l1.val <= l2.val){
            l1.next = mergeTwoLists(l1.next,l2);
            return l1;
        }
        else{
            l2.next = mergeTwoLists(l2.next,l1);
            return l2;
        }
    }
}

22. 括号生成（中等）

题目：数字 n 代表生成括号的对数，请你设计一个函数，用于能够生成所有可能的并且 有效的 括号组合。

输入：n = 3
输出：["((()))","(()())","(())()","()(())","()()()"] 

输入：n = 1
输出：["()"]

 （一开始还没看懂怎么这么多括号，后来才发现结果是String数组的意思……）

思路：dfs
左右括号数量相同。终止条件是左右括号都没有了。
对于有左括号的情况，优先添加左括号。左括号多于右括号时，可以添加右括号。

class Solution {
    List<String> res = new LinkedList<>();
    public List<String> generateParenthesis(int n) {
        dfs(n, n, "");
        return res;
    }
    private void dfs(int left, int right, String str){
        if(left == 0 && right == 0){
            res.add(str);
            return;
        }
        if(left > 0)
            dfs(left - 1, right, str + "(");
        if(right > left)
            dfs(left, right - 1, str + ")");
    }
}

23. 合并K个升序链表（困难）

暂略

31. 下一个排列（中等）

题目：实现获取 下一个排列 的函数，算法需要将给定数字序列重新排列成字典序中下一个更大的排列（即，组合出下一个更大的整数）。
如果不存在下一个更大的排列，则将数字重新排列成最小的排列（即升序排列）。
必须 原地 修改，只允许使用额外常数空间。

输入：nums = [1,2,3]
输出：[1,3,2]

思路：从后往前找，对于每一位，他后面有没有比他更大的可以替换过来。
注意交换后要将交换的高位后面排序，以及如果不存在要重新排序成最小序列。
因为题目中条件1 <= nums.length <= 100，因此可以将101作为是否找到了的标志。

class Solution {
    public void nextPermutation(int[] nums) {
        for(int i = nums.length - 2;i >= 0;i--){
            int min = 101;
            int k = 0;
            for(int j = nums.length - 1;j > i;j--){
                if(n