add leetcode

LeetCode/112_路径总和/README.md

@@ -0,0 +1,26 @@
+# 路径总和
+
+## 来源
+
+https://leetcode-cn.com/problems/path-sum/
+
+## 描述
+
+给定一个二叉树和一个目标和，判断该树中是否存在根节点到叶子节点的路径，这条路径上所有节点值相加等于目标和
+
+说明：叶子节点是指没有子节点的节点
+
+```bash
+示例
+给定如下二叉树，以及目标和 sum = 22
+              5
+             / \
+            4   8
+           /   / \
+          11  13  4
+         /  \      \
+        7    2      1
+
+返回 true, 因为存在目标和为 22 的根节点到叶子节点的路径 5->4->11->2。
+```
+

LeetCode/146_LRU缓存机制/README.md

@@ -54,8 +54,14 @@ class LRUCache(object):
 
     def put(self, key, value):
         if self.size < self.capacity:
-            if self.map.get(key):
+            if self.map.get(key):                                
+                # 将该元素移动到最新使用的
+                index = self.array.index(key)
+                del self.array[index]
+                self.array.append(key)
+                # 更新key
                 self.map[key] = value
+
             else:
                 self.map[key] = value
                 self.array.append(key)
@@ -87,3 +93,194 @@ if __name__ == '__main__':
     print(cache.get(2))
 ```
 
+## 代码2
+
+上面使用的是数组，我们知道使用数组的时间复杂度在O(n)，因为删除元素需要进行移动，那么我们就可以使用双向链表 + 哈希 来实现
+
+```python
+# 双向List
+class Node(object):
+    def __init__(self, val=None, key=None, left=None, right=None):
+        # 键
+        self.key = key
+        # 值
+        self.val = val
+        self.left = left
+        self.right = right
+
+class LRUCache(object):
+    def __init__(self, capacity):
+        self.capacity = capacity
+        self.map = {}
+        self.array = []
+        self.size = 0
+        self.root = None
+
+    def get(self, key):
+        if self.map.get(key):
+            node = self.map.get(key)
+            # 判断要删除的是不是根节点
+            if key != self.root.key:
+                # 移除使用的节点，将其移动到最后
+                leftNode = node.left
+                rightNode = node.right
+                leftNode.right = rightNode
+                rightNode.left = leftNode
+
+                # 将该节点放到最后
+                leftRoot = self.root.left
+                leftRoot.right = node
+                node.left = leftRoot
+                node.right = self.root
+                self.root.left = node
+                return node.val
+            else:
+                leftNode = node.left
+                rightNode = node.right
+                leftNode.right = rightNode
+                rightNode.left = leftNode
+
+                # 将该节点放到最后
+                leftRoot = self.root.left
+                rightRoot = self.root.right
+                leftRoot.right = node
+                node.left = leftRoot
+                node.right = rightRoot
+                self.root = rightRoot
+                return node.val
+
+        else:
+            return -1
+
+    def put(self, key, value):
+        if self.size < self.capacity:
+            if self.size == 0:
+                # 插入的是第一个节点，那么就是root节点，双向循环链表
+                node = Node()
+                node.key = key
+                node.val = value
+                node.left = node
+                node.right = node
+                self.root = node
+                self.map[key] = node
+                self.size += 1
+            elif self.map.get(key):
+                # 将该元素移动到最新使用的
+                node = self.map.get(key)
+                node.val = value
+
+                # 判断要删除的是不是根节点
+                if key != self.root.key:
+                    # 移除使用的节点，将其移动到最后
+                    leftNode = node.left
+                    rightNode = node.right
+                    leftNode.right = rightNode
+                    rightNode.left = leftNode
+
+                    # 将该节点放到最后
+                    leftRoot = self.root.left
+                    leftRoot.right = node
+                    node.left = leftRoot
+                    node.right = self.root
+                    self.root.left = node
+                    self.map[key] = node
+                else:
+                    leftNode = node.left
+                    rightNode = node.right
+                    leftNode.right = rightNode
+                    rightNode.left = leftNode
+
+                    # 将该节点放到最后
+                    leftRoot = self.root.left
+                    rightRoot = self.root.right
+                    leftRoot.right = node
+                    node.left = leftRoot
+                    node.right = rightRoot
+                    self.root = rightRoot
+                    self.map[key] = node
+
+                # # 将该元素移动到最新使用的
+                # node = self.map.get(key)
+                # # 更新元素中的值
+                # node.val = value
+                # node.key = key
+                # # 移除使用的节点，将其移动到最后
+                # leftNode = node.left
+                # rightNode = node.right
+                # leftNode.right = rightNode
+                # rightNode.left = leftNode
+                #
+                # # 将该节点放到最后
+                # leftRoot = self.root.left
+                # leftRoot.left = node
+                # node.left = leftRoot
+                # node.right = self.root
+                # self.root.left = node
+
+
+            else:
+                leftRoot = self.root.left
+                node = Node()
+                node.val = value
+                node.key = key
+                node.left = leftRoot
+                node.right = self.root
+                leftRoot.right = node
+                self.root.left = node
+                self.map[key] = node
+                self.size += 1
+        else:
+            # 以下代码是淘汰策略，当不需要淘汰的时候
+            if self.map.get(key):
+                # 将该元素移动到最新使用的
+                node = self.map.get(key)
+
+                leftRoot = self.root.left
+                rightRoot = self.root.right
+
+                # 更新元素中的值
+                node.val = value
+                # 移除使用的节点，将其移动到最后
+                leftNode = node.left
+                rightNode = node.right
+                leftNode.right = rightNode
+                rightNode.left = leftNode
+
+                # 将该节点放到最后
+                leftRoot = self.root.left
+                leftRoot.left = node
+                node.left = leftRoot
+                node.right = rightRoot
+                self.root.left = node
+                self.root = rightNode
+
+            else:
+                deleteKey = self.root.key
+                del self.map[deleteKey]
+                leftRoot = self.root.left
+                rightRoot = self.root.right
+                node = Node()
+                node.key = key
+                node.val = value
+                node.left = leftRoot
+                node.right = rightRoot
+                leftRoot.right = node
+                rightRoot.left = node
+                self.root = rightRoot
+                self.map[key] = node
+                self.size += 1
+
+
+if __name__ == '__main__':
+    cache = LRUCache(2)
+    cache.put(1, 1)
+    cache.put(2, 2)
+    print(cache.get(1))
+    cache.put(3, 3)
+    print(cache.get(2))
+    cache.put(4, 4)
+    print(cache.get(1))
+    print(cache.get(3))
+    print(cache.get(4))
+```
+

LeetCode/199_二叉树的右视图/README.md

@@ -0,0 +1,99 @@
+# 二叉树的右视图
+
+## 来源
+
+https://leetcode-cn.com/problems/binary-tree-right-side-view/
+
+## 描述
+
+给定一棵二叉树，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。
+
+```bash
+示例:
+
+输入: [1,2,3,null,5,null,4]
+输出: [1, 3, 4]
+解释:
+
+   1            <---
+ /   \
+2     3         <---
+ \     \
+  5     4       <---
+```
+
+
+
+## 代码1（错误）
+
+最开始的想法就是一直匹配最右边，当该节点没有最右侧的子树时，再去匹配它的左子树，然后再去寻找最右侧
+
+```python
+class Solution(object):
+    def rightSideView(self, root):
+        if root == None:
+            return []
+        ret = [root.val]
+        while root.right or root.left:
+            rightNode = root.right
+            if rightNode == None:
+                leftNode = root.left
+                ret.append(leftNode.val)
+                root = root.left
+            else:
+                ret.append(rightNode.val)
+                root = root.right
+        return ret
+```
+
+但是遇到这样的情况的话，是有问题的
+
+```
+   1            <---
+ /   \
+2     3         <---
+  \    
+   4           <---
+```
+
+也就是上面的程序只会输出  1 3  而最后的结果应该是  1 3 4
+
+## 代码2
+
+因为之前还做过二叉树的层次遍历这道题，想着右侧视图，不就是层次遍历时候的最右侧的节点么？想到这里，就重新复现了一下二叉树的层次遍历的代码~，然后通过一个状态位来记录 最右侧的节点
+
+```python
+class Solution(object):
+    def rightSideView(self, root):
+        if root == None:
+            return []
+        ret = []
+        stack = [root]
+        secondStack = []
+        while stack or secondStack:
+            count = 0
+            while stack:
+                node = stack.pop()
+                if count == 0:
+                    ret.append(node.val)
+                count += 1
+
+                if node.right:
+                    secondStack.insert(0, node.right)
+                if node.left:
+                    secondStack.insert(0, node.left)
+
+            count = 0
+            while secondStack:
+                node = secondStack.pop()
+                if count == 0:
+                    ret.append(node.val)
+                count += 1
+
+                if node.right:
+                    stack.insert(0, node.right)                
+                if node.left:
+                    stack.insert(0, node.left)
+        return ret
+```
+