add #17 #18 python implement

notes/面试总结.md

@@ -18,6 +18,8 @@
 * [14. 剪绳子](#14-剪绳子)
 * [15. 二进制中 1 的个数](#15-二进制中-1-的个数)
 * [16. 数值的整数次方](#16-数值的整数次方)
+* [17. 打印从 1 到最大的 n 位数](#17-打印从-1-到最大的-n-位数)
+* [18.1 在 O(1) 时间内删除链表节点](#181-在-o1-时间内删除链表节点)
 
 * [参考文献](#参考文献)
 <!-- GFM-TOC -->
@@ -1239,6 +1241,98 @@ public int integerBreak(int n) {
     return dp[n];
 }
 ```
+# 17. 打印从 1 到最大的 n 位数
+
+## 题目描述
+
+输入数字 n，按顺序打印出从 1 到最大的 n 位十进制数。比如输入 3，则打印出 1、2、3 一直到最大的 3 位数即 999。
+
+## 解题思路
+
+由于 n 可能会非常大，因此不能直接用 int 表示数字，而是用 char 数组进行存储。
+
+使用回溯法得到所有的数。
+
+```java
+public void print1ToMaxOfNDigits(int n) {
+    if (n <= 0)
+        return;
+    char[] number = new char[n];
+    print1ToMaxOfNDigits(number, 0);
+}
+
+private void print1ToMaxOfNDigits(char[] number, int digit) {
+    if (digit == number.length) {
+        printNumber(number);
+        return;
+    }
+    for (int i = 0; i < 10; i++) {
+        number[digit] = (char) (i + '0');
+        print1ToMaxOfNDigits(number, digit + 1);
+    }
+}
+
+private void printNumber(char[] number) {
+    int index = 0;
+    while (index < number.length && number[index] == '0')
+        index++;
+    while (index < number.length)
+        System.out.print(number[index++]);
+    System.out.println();
+}
+```
+
+```python
+def numbersByRecursion(n,largest,result):
+    def recursion(num,largest,result):
+        if num <= largest:
+            result.append(num)
+            return recursion(num+1,largest,result) 
+        else:
+            return result
+    return recursion(n,largest,result)
+
+
+
+
+n = 2        
+result = [] 
+largest = pow(10,n)-1
+re = numbersByRecursion(1, largest, result)
+print (re)
+```
+# 18.1 在 O(1) 时间内删除链表节点
+
+## 解题思路
+
+① 如果该节点不是尾节点，那么可以直接将下一个节点的值赋给该节点，然后令该节点指向下下个节点，再删除下一个节点，时间复杂度为 O(1)。
+
+<div align="center"> <img src="../pics//27ff9548-edb6-4465-92c8-7e6386e0b185.png" width="600"/> </div><br>
+
+② 否则，就需要先遍历链表，找到节点的前一个节点，然后让前一个节点指向 null，时间复杂度为 O(N)。
+
+<div align="center"> <img src="../pics//280f7728-594f-4811-a03a-fa8d32c013da.png" width="600"/> </div><br>
+
+综上，如果进行 N 次操作，那么大约需要操作节点的次数为 N-1+N=2N-1，其中 N-1 表示 N-1 个不是尾节点的每个节点以 O(1) 的时间复杂度操作节点的总次数，N 表示 1 个尾节点以 O(N) 的时间复杂度操作节点的总次数。(2N-1)/N \~ 2，因此该算法的平均时间复杂度为 O(1)。
+
+```java
+public ListNode deleteNode(ListNode head, ListNode tobeDelete) {
+    if (head == null || head.next == null || tobeDelete == null)
+        return null;
+    if (tobeDelete.next != null) {
+        // 要删除的节点不是尾节点
+        ListNode next = tobeDelete.next;
+        tobeDelete.val = next.val;
+        tobeDelete.next = next.next;
+    } else {
+        ListNode cur = head;
+        while (cur.next != tobeDelete)
+            cur = cur.next;
+        cur.next = null;
+    }
+    return head;
+}
+```
 
 
 ### 动态规划
@@ -1254,6 +1348,97 @@ public int integerBreak(int n) {
 }
 ```
 
+```python
+class ListNode:
+    def __init__(self, x = None):
+        self.val = x
+        self.next = None
+    def __del__(self):
+        self.val = None
+        self.next = None
+        
+class Solution:
+    def list_generate(self, lst):
+        """
+        生成链表
+        """
+        if not lst:
+            return None
+        list_node = ListNode()
+        list_node.value = lst[0]
+        if len(lst) == 1:
+            list_node.next_node = None
+        else:
+            list_node.next_node = self.list_generate(lst[1:])
+        return list_node
+        
+    def find_node(self, node, target_value):
+        """
+        根据给定的目标值，找出指定节点的位置
+        非题目要求，只是为了测试验证
+        """
+        if not target_value:
+            return False
+        while node:
+            if node.value == target_value:
+                return node
+            node = node.next_node
+        return False
+    
+    def delete_node(self, head_node, del_node):
+        """
+        删除指定节点
+        """
+        if not (head_node and del_node):
+            return False
+
+        if del_node.next_node:
+            # 删除的节点不是尾节点，而且不是唯一一个节点
+            del_next_node = del_node.next_node
+            del_node.value = del_next_node.value
+            del_node.next_node = del_next_node.next_node
+            del_next_node.__del__()
+            del_next_node.__del__()
+
+        elif del_node == head_node:
+            # 唯一一个节点，删除头节点
+            head_node = None
+            del_node = None
+
+        else:
+            # 删除节点为尾节点
+            node = head_node
+            while node.next_node != del_node:
+                node = node.next_node
+
+            node.next_node = None
+            del_node = None
+
+        return head_node
+
+            
+            
+if __name__ == '__main__':
+    solution = Solution()
+    head_node = solution.list_generate(['a', 'b', 'c', 'e', 'd', 'd'])
+    
+    target_value = 'a'
+    target_node = solution.find_node(head_node, target_value)
+    if target_node:
+        print (target_node.value)
+    head_node = solution.delete_node(head_node, target_node)
+    
+    
+    node = head_node
+    if node:
+        while node:
+            print (node.value)
+            node = node.next_node
+            if node:
+                print ('->')
+    else:
+        print ('wrong')
+```
 
 # 参考文献