1. 新增部分题目

leosanqing · leosanqing · commit ea56c2378100 · 2020-07-08T18:52:50.000+08:00
diff --git a/java-note-algorithm/src/main/java/com/leosanqing/leetcode/easy/list/_21_merge_two_sorted_lists.java b/java-note-algorithm/src/main/java/com/leosanqing/leetcode/easy/list/_21_merge_two_sorted_lists.java
@@ -0,0 +1,80 @@
+package com.leosanqing.leetcode.easy.list;
+
+/**
+ * @Author: rtliu
+ * @Date: 2020/7/7 &#19979;&#21320;4:46
+ * @Package: com.leosanqing.leetcode.easy.list
+ * @Description: Merge two sorted linked lists and return it as a new sorted list.
+ * The new list should be made by splicing together the nodes of the first two lists.
+ * Example:
+ * Input: 1->2->4, 1->3->4
+ * Output: 1->1->2->3->4->4
+ * @Version: 1.0
+ */
+public class _21_merge_two_sorted_lists {
+
+    public static void main(String[] args) {
+        ListNode node1 = new ListNode(4);
+        ListNode node2 = new ListNode(2,node1);
+        ListNode node3 = new ListNode(1,node2);
+        ListNode node4 = new ListNode(4);
+        ListNode node5 = new ListNode(3,node4);
+        ListNode node6 = new ListNode(1,node5);
+
+        System.out.println(mergeTwoLists(node3,node6));
+    }
+
+    public static ListNode mergeTwoLists(ListNode l1, ListNode l2) {
+
+        if (l1 == null && l2 == null) {
+            return new ListNode();
+        } else if (l1 == null) {
+            return l2;
+        } else if (l2 == null) {
+            return l1;
+        }
+
+        ListNode newList = new ListNode();
+        ListNode fakeHead = newList;
+        ListNode curr1 = l1;
+        ListNode curr2 = l2;
+
+        while (curr1 != null && curr2 != null) {
+            if (curr1.val <= curr2.val) {
+                newList.next = curr1;
+                curr1 = curr1.next;
+            }else {
+                newList.next = curr2;
+                curr2 = curr2.next;
+            }
+            newList = newList.next;
+        }
+
+        if(curr1 != null){
+            newList.next = curr1;
+        }
+        if(curr2 != null){
+            newList.next = curr2;
+        }
+
+        return fakeHead.next;
+    }
+
+
+    static class ListNode {
+        int val;
+        ListNode next;
+
+        ListNode() {
+        }
+
+        ListNode(int val) {
+            this.val = val;
+        }
+
+        ListNode(int val, ListNode next) {
+            this.val = val;
+            this.next = next;
+        }
+    }
+}
diff --git a/java-note-algorithm/src/main/java/com/leosanqing/leetcode/easy/string/_20_valid_parentheses.java b/java-note-algorithm/src/main/java/com/leosanqing/leetcode/easy/string/_20_valid_parentheses.java
@@ -0,0 +1,64 @@
+package com.leosanqing.leetcode.easy.string;
+
+import java.util.Stack;
+
+/**
+ * @Author: rtliu
+ * @Date: 2020/7/7 &#19979;&#21320;4:20
+ * @Package: com.leosanqing.leetcode.easy.string
+ * @Description: `     Given a string containing just the characters '(', ')', '{', '}', '[' and ']',
+ * `     determine if the input string is valid.
+ * `     An input string is valid if:
+ * `     Open brackets must be closed by the same type of brackets.
+ * `     Open brackets must be closed in the correct order.
+ * `     Note that an empty string is also considered valid.
+ * `  Example 1:
+ * `     Input: "()"
+ * `     Output: true
+ * `  Example 2:
+ * `     Input: "()[]{}"
+ * `     Output: true
+ * `  Example 3:
+ * `     Input: "(]"
+ * `     Output: false
+ * `  Example 4:
+ * `     Input: "([)]"
+ * `     Output: false
+ * `  Example 5:
+ * `     Input: "{[]}"
+ * `     Output: true
+ * @Version: 1.0
+ */
+public class _20_valid_parentheses {
+    public static void main(String[] args) {
+
+    }
+
+    public boolean isValid(String s) {
+
+        if (s == null || "".equals(s)) {
+            return true;
+        }
+
+        char[] charArray = s.toCharArray();
+        if (charArray.length % 2 != 0) {
+            return false;
+        }
+
+        Stack<Character> stack = new Stack<>();
+        for (char c : charArray) {
+            if (c == '[') {
+                stack.push(']');
+            } else if (c == '(') {
+                stack.push(')');
+            } else if (c == '{') {
+                stack.push('}');
+            } else if (stack.isEmpty() || stack.pop() != c) {
+                return false;
+            }
+
+        }
+
+        return stack.isEmpty();
+    }
+}
diff --git a/java-note-algorithm/src/main/java/com/leosanqing/leetcode/medium/array/_17_letter_combinations_of_a_phone_number.java b/java-note-algorithm/src/main/java/com/leosanqing/leetcode/medium/array/_17_letter_combinations_of_a_phone_number.java
@@ -24,9 +24,13 @@ public static void main(String[] args) {
     }
 
     public static List<String> letterCombinations(String digits) {
+        List<String> list = new LinkedList<>();
+        if(digits == null || "".equals(digits)){
+            return list;
+        }
         char[] charArray = digits.toCharArray();
 
-        List<String> list = new LinkedList<>();
+
         char[][] map = {
                 {},
                 {},
diff --git a/java-note-algorithm/src/main/java/com/leosanqing/leetcode/medium/list/_19_remove_Nth_node_from_end_of_list.java b/java-note-algorithm/src/main/java/com/leosanqing/leetcode/medium/list/_19_remove_Nth_node_from_end_of_list.java
@@ -0,0 +1,74 @@
+package com.leosanqing.leetcode.medium.list;
+
+/**
+ * @Author: rtliu
+ * @Date: 2020/7/7 &#19979;&#21320;3:47
+ * @Package: com.leosanqing.leetcode.medium.list
+ * @Description: Given a linked list, remove the n-th node from the end of list and return its head.
+ *
+ *
+ *` `Example:
+ *` `     Give linked list: 1->2->3->4->5, and n = 2.
+ *` `     After removing the second node from the end, the linked list becomes
+ *` `     1->2->3->5.
+ *` `     Note:  Given n will always be valid.
+ * @Version: 1.0
+ */
+public class _19_remove_Nth_node_from_end_of_list {
+
+    public static void main(String[] args) {
+
+    }
+
+    /**
+     * &#24605;&#36335;&#23601;&#26159;&#20351;&#29992;&#20004;&#20010;&#33410;&#28857;&#65292;&#19968;&#20010;&#24555;&#33410;&#28857;&#20808;&#36208; n&#27493;&#65292;&#28982;&#21518;&#24555;&#33410;&#28857;&#36208;&#21040;&#26368;&#21518;&#65292;&#21518;&#38754;&#30340;&#37027;&#20010;&#33410;&#28857;&#23601;&#26159;&#25105;&#20204;&#35201;&#21435;&#25481;&#30340;&#33410;&#28857;
+     * &#35774;&#32622;&#19968;&#20010;&#34394;&#25311;&#22836;&#32467;&#28857;&#65292;&#21487;&#20197;&#24110;&#21161;&#25105;&#20204;&#35299;&#20915;&#36793;&#30028;&#20540;&#38382;&#39064;
+     * @param head
+     * @param n
+     * @return
+     */
+    public ListNode removeNthFromEnd(ListNode head, int n) {
+
+        // &#35774;&#32622;&#19968;&#20010;&#34394;&#25311;&#30340;&#22836;&#32467;&#28857;&#65292;&#20415;&#20110;&#21518;&#38754;&#20570;&#36793;&#30028;&#20540;&#21028;&#26029;
+        ListNode  fakeHead = new ListNode();
+        fakeHead.next = head;
+
+        // &#24555;&#33410;&#28857;&#65292;&#29992;&#20110;&#35760;&#24405;n
+        ListNode fastNode = head;
+        for (int i = 0; i < n; i++) {
+            fastNode = fastNode.next;
+        }
+        ListNode pre = fakeHead;
+        ListNode curr = head;
+        while (fastNode != null) {
+            fastNode = fastNode.next;
+            pre = curr;
+            curr = curr.next;
+        }
+
+
+        pre.next = curr.next;
+
+
+        return fakeHead.next;
+    }
+
+
+    static class ListNode {
+        int val;
+        ListNode next;
+
+        ListNode() {
+        }
+
+        ListNode(int val) {
+            this.val = val;
+        }
+
+        ListNode(int val, ListNode next) {
+            this.val = val;
+            this.next = next;
+        }
+    }
+
+}
