Merge branch 'master' of github.com:youngyangyang04/leetcode-master

problems/0001.两数之和.md

@@ -41,7 +41,7 @@
 
 那么我们就应该想到使用哈希法了。
 
-因为本地，我们不仅要知道元素有没有遍历过，还有知道这个元素对应的下标，**需要使用 key value结构来存放，key来存元素，value来存下标，那么使用map正合适**。 
+因为本地，我们不仅要知道元素有没有遍历过，还要知道这个元素对应的下标，**需要使用 key value结构来存放，key来存元素，value来存下标，那么使用map正合适**。 
 
 再来看一下使用数组和set来做哈希法的局限。
 

problems/0017.电话号码的字母组合.md

@@ -287,99 +287,154 @@ class Solution {
 ```
 
 ## Python 
-**回溯**
+回溯
 ```python
 class Solution:
     def __init__(self):
-        self.answers: List[str] = []
-        self.answer: str = ''
-        self.letter_map = {
-            '2': 'abc',
-            '3': 'def',
-            '4': 'ghi',
-            '5': 'jkl',
-            '6': 'mno',
-            '7': 'pqrs',
-            '8': 'tuv',
-            '9': 'wxyz'
-        }
-
-    def letterCombinations(self, digits: str) -> List[str]:
-        self.answers.clear()
-        if not digits: return []
+        self.letterMap = [
+            "",     # 0
+            "",     # 1
+            "abc",  # 2
+            "def",  # 3
+            "ghi",  # 4
+            "jkl",  # 5
+            "mno",  # 6
+            "pqrs", # 7
+            "tuv",  # 8
+            "wxyz"  # 9
+        ]
+        self.result = []
+        self.s = ""
+
+    def backtracking(self, digits, index):
+        if index == len(digits):
+            self.result.append(self.s)
+            return
+        digit = int(digits[index])    # 将索引处的数字转换为整数
+        letters = self.letterMap[digit]    # 获取对应的字符集
+        for i in range(len(letters)):
+            self.s += letters[i]    # 处理字符
+            self.backtracking(digits, index + 1)    # 递归调用，注意索引加1，处理下一个数字
+            self.s = self.s[:-1]    # 回溯，删除最后添加的字符
+
+    def letterCombinations(self, digits):
+        if len(digits) == 0:
+            return self.result
         self.backtracking(digits, 0)
-        return self.answers
+        return self.result
+
+```
+回溯精简（版本一）
+```python
+class Solution:
+    def __init__(self):
+        self.letterMap = [
+            "",     # 0
+            "",     # 1
+            "abc",  # 2
+            "def",  # 3
+            "ghi",  # 4
+            "jkl",  # 5
+            "mno",  # 6
+            "pqrs", # 7
+            "tuv",  # 8
+            "wxyz"  # 9
+        ]
+        self.result = []
 
-    def backtracking(self, digits: str, index: int) -> None:
-        # 回溯函数没有返回值
-        # Base Case
-        if index == len(digits):    # 当遍历穷尽后的下一层时
-            self.answers.append(self.answer)
-            return 
-        # 单层递归逻辑  
-        letters: str = self.letter_map[digits[index]]
+    def getCombinations(self, digits, index, s):
+        if index == len(digits):
+            self.result.append(s)
+            return
+        digit = int(digits[index])
+        letters = self.letterMap[digit]
         for letter in letters:
-            self.answer += letter   # 处理
-            self.backtracking(digits, index + 1)    # 递归至下一层
-            self.answer = self.answer[:-1]  # 回溯
+            self.getCombinations(digits, index + 1, s + letter)
+
+    def letterCombinations(self, digits):
+        if len(digits) == 0:
+            return self.result
+        self.getCombinations(digits, 0, "")
+        return self.result
+
 ```
-**回溯简化**
+回溯精简（版本二）
 ```python
 class Solution:
     def __init__(self):
-        self.answers: List[str] = []
-        self.letter_map = {
-            '2': 'abc',
-            '3': 'def',
-            '4': 'ghi',
-            '5': 'jkl',
-            '6': 'mno',
-            '7': 'pqrs',
-            '8': 'tuv',
-            '9': 'wxyz'
-        }
-
-    def letterCombinations(self, digits: str) -> List[str]:
-        self.answers.clear()
-        if not digits: return []
-        self.backtracking(digits, 0, '')
-        return self.answers
+        self.letterMap = [
+            "",     # 0
+            "",     # 1
+            "abc",  # 2
+            "def",  # 3
+            "ghi",  # 4
+            "jkl",  # 5
+            "mno",  # 6
+            "pqrs", # 7
+            "tuv",  # 8
+            "wxyz"  # 9
+        ]
 
-    def backtracking(self, digits: str, index: int, answer: str) -> None:
-        # 回溯函数没有返回值
-        # Base Case
-        if index == len(digits):    # 当遍历穷尽后的下一层时
-            self.answers.append(answer)
-            return 
-        # 单层递归逻辑  
-        letters: str = self.letter_map[digits[index]]
+    def getCombinations(self, digits, index, s, result):
+        if index == len(digits):
+            result.append(s)
+            return
+        digit = int(digits[index])
+        letters = self.letterMap[digit]
         for letter in letters:
-            self.backtracking(digits, index + 1, answer + letter)    # 递归至下一层 + 回溯
+            self.getCombinations(digits, index + 1, s + letter, result)
+
+    def letterCombinations(self, digits):
+        result = []
+        if len(digits) == 0:
+            return result
+        self.getCombinations(digits, 0, "", result)
+        return result
+
+
 ```
-**使用itertools**
+
+回溯优化使用列表
 ```python
 class Solution:
-    def letterCombinations(self, digits: str) -> List[str]:
-        import itertools
-        if not digits:
-            return list()
-
-        phoneMap = {
-            "2": "abc",
-            "3": "def",
-            "4": "ghi",
-            "5": "jkl",
-            "6": "mno",
-            "7": "pqrs",
-            "8": "tuv",
-            "9": "wxyz",
-        }
+    def __init__(self):
+        self.letterMap = [
+            "",     # 0
+            "",     # 1
+            "abc",  # 2
+            "def",  # 3
+            "ghi",  # 4
+            "jkl",  # 5
+            "mno",  # 6
+            "pqrs", # 7
+            "tuv",  # 8
+            "wxyz"  # 9
+        ]
+
+    def getCombinations(self, digits, index, path, result):
+        if index == len(digits):
+            result.append(''.join(path))
+            return
+        digit = int(digits[index])
+        letters = self.letterMap[digit]
+        for letter in letters:
+            path.append(letter)
+            self.getCombinations(digits, index + 1, path, result)
+            path.pop()
+
+    def letterCombinations(self, digits):
+        result = []
+        if len(digits) == 0:
+            return result
+        self.getCombinations(digits, 0, [], result)
+        return result
+
+
 
-        groups = (phoneMap[digit] for digit in digits)
-        return ["".join(combination) for combination in itertools.product(*groups)]
 ```
 
 
+
 ## Go 
 
 主要在于递归中传递下一个数字

problems/0019.删除链表的倒数第N个节点.md

@@ -412,6 +412,28 @@ struct ListNode* removeNthFromEnd(struct ListNode* head, int n) {
 
 ```
 
+C#：
+```csharp
+public class Solution {
+    public ListNode RemoveNthFromEnd(ListNode head, int n) {
+        ListNode dummpHead = new ListNode(0);
+        dummpHead.next = head;
+        var fastNode = dummpHead;
+        var slowNode = dummpHead;
+        while(n-- != 0 && fastNode != null)
+        {
+            fastNode = fastNode.next;
+        }
+        while(fastNode.next != null)
+        {
+            fastNode = fastNode.next;
+            slowNode = slowNode.next;
+        }
+        slowNode.next = slowNode.next.next;
+        return dummpHead.next;
+    }
+}
+```
 <p align="center">
 <a href="https://programmercarl.com/other/kstar.html" target="_blank">
   <img src="../pics/网站星球宣传海报.jpg" width="1000"/>

problems/0035.搜索插入位置.md

@@ -191,8 +191,8 @@ public:
 };
 ```
 
-* 时间复杂度：$O(\log n)$
-* 时间复杂度：$O(1)$
+* 时间复杂度：O(log n)
+* 空间复杂度：O(1)
 
 ## 总结