python_145

Author: OnlyChristmas

C++/剑指Offer名企面试官精讲典型编程题.pdf

@@ -36,6 +36,10 @@ def deleteNode(self, node):
         :type node: ListNode
         :rtype: void Do not return anything, modify node in-place instead.
         """
+        # 首先，如果时间复杂度为O（1），那么以下爱代码是基于删除的节点必定再到航前链表中为假设前提的。
+        # 分为两种情况，
+        # 1、如果要删除的结点不是尾节点，可以直接删除。
+        # 2、否则还是需要遍历到链表的末尾，这是最坏情况。
 
         node.val = node.next.val
         node.next = node.next.next

Python/delete-node-in-a-linked-list.py

@@ -0,0 +1,79 @@
+'''
+
+
+Implement the following operations of a queue using stacks.
+
+push(x) -- Push element x to the back of queue.
+pop() -- Removes the element from in front of queue.
+peek() -- Get the front element.
+empty() -- Return whether the queue is empty.
+Example:
+
+MyQueue queue = new MyQueue();
+
+queue.push(1);
+queue.push(2);
+queue.peek();  // returns 1
+queue.pop();   // returns 1
+queue.empty(); // returns false
+Notes:
+
+You must use only standard operations of a stack -- which means only push to top, peek/pop from top, size, and is empty operations are valid.
+Depending on your language, stack may not be supported natively. You may simulate a stack by using a list or deque (double-ended queue), as long as you use only standard operations of a stack.
+You may assume that all operations are valid (for example, no pop or peek operations will be called on an empty queue).
+
+
+'''
+
+
+
+class MyQueue:
+
+    def __init__(self):
+        """
+        Initialize your data structure here.
+        """
+        self.stack = []
+
+
+
+    def push(self, x: int) -> None:
+        """
+        Push element x to the back of queue.
+        """
+        self.stack.append(x)
+
+
+    def pop(self) -> int:
+        """
+        Removes the element from in front of queue and returns that element.
+        """
+        if self.stack: return self.stack.pop(0)
+        else: return None
+
+
+    def peek(self) -> int:
+        """
+        Get the front element.
+        """
+
+        if self.stack: return self.stack[0]
+        else: return None
+
+    def empty(self) -> bool:
+        """
+        Returns whether the queue is empty.
+        """
+
+        if self.stack == []: return True
+        else: return False
+
+
+
+
+# Your MyQueue object will be instantiated and called as such:
+# obj = MyQueue()
+# obj.push(x)
+# param_2 = obj.pop()
+# param_3 = obj.peek()
+# param_4 = obj.empty()

Python/implement-queue-using-stacks.py

@@ -0,0 +1,97 @@
+'''
+Implement the following operations of a stack using queues.
+
+push(x) -- Push element x onto stack.
+pop() -- Removes the element on top of the stack.
+top() -- Get the top element.
+empty() -- Return whether the stack is empty.
+Example:
+
+MyStack stack = new MyStack();
+
+stack.push(1);
+stack.push(2);
+stack.top();   // returns 2
+stack.pop();   // returns 2
+stack.empty(); // returns false
+Notes:
+
+You must use only standard operations of a queue -- which means only push to back, peek/pop from front, size, and is empty operations are valid.
+Depending on your language, queue may not be supported natively. You may simulate a queue by using a list or deque (double-ended queue), as long as you use only standard operations of a queue.
+You may assume that all operations are valid (for example, no pop or top operations will be called on an empty stack).
+
+'''
+
+
+class MyStack:
+
+    def __init__(self):
+        """
+        Initialize your data structure here.
+        """
+        self.q1 = []
+        self.q2 = []
+
+
+    def push(self, x: int) -> None:
+        """
+        Push element x onto stack.
+        """
+        if self.q1: self.q1.append(x)
+        else: self.q2.append(x)
+
+    def pop(self) -> int:
+        """
+        Removes the element on top of the stack and returns that element.
+        """
+        if self.q1:
+            while len(self.q1) > 1:
+                self.q2.append(self.q1.pop(0))
+            return self.q1.pop(0)
+        else:
+            while len(self.q2) > 1:
+                self.q1.append(self.q2.pop(0))
+            return self.q2.pop(0)
+
+
+
+    def top(self) -> int:
+        """
+        Get the top element.
+        """
+        if self.q1:
+            while len(self.q1) > 1:
+                self.q2.append(self.q1.pop(0))
+            key = self.q1.pop(0)
+            self.q2.append(key)
+            return key
+        else:
+            while len(self.q2) > 1:
+                self.q1.append(self.q2.pop(0))
+            key = self.q2.pop(0)
+            self.q1.append(key)
+            return key
+
+    def empty(self) -> bool:
+        """
+        Returns whether the stack is empty.
+        """
+        return self.q1 == [] and self.q2 == []
+
+
+
+# Your MyStack object will be instantiated and called as such:
+# obj = MyStack()
+# obj.push(x)
+# param_2 = obj.pop()
+# param_3 = obj.top()
+# param_4 = obj.empty()
+
+
+
+# Your MyStack object will be instantiated and called as such:
+# obj = MyStack()
+# obj.push(x)
+# param_2 = obj.pop()
+# param_3 = obj.top()
+# param_4 = obj.empty()

Python/implement-stack-using-queues.py

@@ -28,7 +28,6 @@
 
 
 
-
 # Definition for a binary tree node.
 # class TreeNode:
 #     def __init__(self, x):
@@ -37,12 +36,30 @@
 #         self.right = None
 
 class Solution:
-    def invertTree(self, root):
-        """
-        :type root: TreeNode
-        :rtype: TreeNode
-        """
-        # method one 一个漂亮的递归（把一个复杂的问题逐步地剥开）
-        if root:
-            root.left, root.right = self.invertTree(root.right), self.invertTree(root.left)
+    def invertTree(self, root: TreeNode) -> TreeNode:
+
+        # Approach one  递归求解
+        # if not root : return None
+        # root.right , root.left = self.invertTree(root.left), self.invertTree(root.right)
+        # return root
+
+
+        # Approach two  栈+循环
+        # if not root : return None
+        # stack = [root]
+        # while stack:
+        #     node = stack.pop()
+        #     node.left , node.right = node.right , node.left
+        #     if node.left : stack.append(node.left)
+        #     if node.right: stack.append(node.right)
+        # return root
+
+        # Approach three  队列也是一样
+        if not root : return None
+        q = [root]
+        while q:
+            node = q.pop()
+            node.left , node.right = node.right , node.left
+            if node.left : q.append(node.left)
+            if node.right: q.append(node.right)
         return root

Python/invert-binary-tree.py

@@ -33,5 +33,8 @@ def maxDepth(self, root):
         :type root: TreeNode
         :rtype: int
         """
+        # 尾递归的程序递归是最后一步，进入递归之后相当于进入了一个新的函数，与当前的函数环境不再交互，不用担心栈溢出，比普通递归消耗的资源较少。
+        # 所以此函数不是尾递归
+
         if not root : return 0
         return max(self.maxDepth(root.left), self.maxDepth(root.right))+1

Python/maximum-depth-of-binary-tree.py

@@ -0,0 +1,54 @@
+'''
+Merge k sorted linked lists and return it as one sorted list. Analyze and describe its complexity.
+
+Example:
+
+Input:
+[
+  1->4->5,
+  1->3->4,
+  2->6
+]
+Output: 1->1->2->3->4->4->5->6
+
+'''
+
+
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, x):
+#         self.val = x
+#         self.next = None
+
+class Solution:
+      # Approach one 分治的思想两两合并  O(NlogK) , O(1)
+    # 想想二叉树，K个有序链表合并可以变成k-1次的“两个有序链表合并问题”
+    def mergeKLists(self, lists: List[ListNode]) -> ListNode:
+
+
+        # def merge2lists(l1,l2):
+        #     if not l1: return l2
+        #     if not l2: return l1
+        #     if l1.val <= l2.val:
+        #         l1.next = merge2lists(l1.next , l2)
+        #         return l1
+        #     else:
+        #         l2.next = merge2lists(l1 , l2.next)
+        #         return l2
+
+
+
+        def merge2lists(l1,l2):
+            res = cur = ListNode(None)
+            while l1 and l2:
+                if l1.val <= l2.val:
+                    cur.next , l1 = l1 , l1.next
+                else:
+                    cur.next , l2 = l2 , l2.next
+                cur = cur.next
+            cur.next = l1 if l1 else l2
+            return res.next
+
+        while len(lists) > 1:
+            lists.append(merge2lists(lists.pop(0),lists.pop(0)))
+        return lists[0] if lists else None  # 注意输入为空

Python/merge-k-sorted-lists.py

@@ -27,28 +27,22 @@ def mergeTwoLists(self, l1, l2):
         """
 
         # Approach one 递归的方法
-#         res = None
 #         if l1 == None:
 #             return l2
 #         elif l2 == None:
 #             return l1
-
 #         if l2.val >= l1.val:
-#             res = l1
-#             res.next =  self.mergeTwoLists(l1.next, l2)
+#             l1.next =  self.mergeTwoLists(l1.next, l2)
+#             return l1
 #         else:
-#             res = l2
-#             res.next =  self.mergeTwoLists(l1, l2.next)
-
-#         return res
-
+#             l2.next =  self.mergeTwoLists(l1, l2.next)
+#             return l2
 
 
 
-        # Approach two  牺牲存储空间，换取时间
-        head = ListNode(0)
-        curr = head
 
+        # Approach two  # 循环的解法需要两个新头结点，并注意拼接尾链
+        head =  curr = ListNode(0)
         while l1 and l2:
             if l1.val >= l2.val:
                 curr.next = l2
@@ -57,9 +51,5 @@ def mergeTwoLists(self, l1, l2):
                 curr.next = l1
                 l1 = l1.next
             curr = curr.next
-        if l1 == None:
-            curr.next = l2
-        if l2 == None:
-            curr.next = l1
-
+        curr.next = l1 if l1 else l2
         return head.next

Python/merge-two-sorted-lists.py

@@ -36,3 +36,27 @@ def hammingWeight(self, n):
             n &= n - 1
             result += 1
         return result
+
+
+        # 复数的补码前面自动填充1
+        # 方法一
+        # return sum([(n>>i & 1) for i in range(0,32)])
+
+        # 方法二
+        # 标志位一路左移，做“与”操作
+        #flag = 1
+        #count = 0
+        #for _ in range(32):
+        #    if flag & n: count += 1
+        #    flag = flag << 1
+        #return count
+
+
+        # python中 -4294967296 的二进制位 Ob0, 虽然一个负数在做了若干次“与”操作后，二进制为零，但是其十进制数是一个越来越小的负数
+        # 因此在采用，“n与(n-1)做与操作恰好去掉n的最右位1”，这一性质时，终止条件不能以十进制来表示，否则是个死循环。
+        # 方法三
+        count = 0
+        while n & 0xffffffff != 0:
+            count += 1
+            n = n & (n - 1)
+        return count