add new solutions

Author: liningrui

script/[109]有序链表转换二叉搜索树.py

@@ -29,7 +29,7 @@
 #  head 中的节点数在[0, 2 * 10⁴] 范围内 
 #  -10⁵ <= Node.val <= 10⁵ 
 #  
-#  Related Topics 树 二叉搜索树 链表 分治 二叉树 👍 729 👎 0
+#  Related Topics 树 二叉搜索树 链表 分治 二叉树 👍 730 👎 0
 
 
 # leetcode submit region begin(Prohibit modification and deletion)
@@ -46,4 +46,23 @@
 #         self.right = right
 class Solution:
     def sortedListToBST(self, head: Optional[ListNode]) -> Optional[TreeNode]:
+        def dfs(start, end):
+            nonlocal head
+            if start>end:
+                return None
+            mid = (start+end)//2
+
+            left= dfs(start, mid-1)
+            root = TreeNode(head.val)
+            head = head.next
+            right = dfs(mid+1, end)
+            root.left = left
+            root.right = right
+            return root
+        counter = 0
+        cur = head
+        while cur:
+            cur = cur.next
+            counter+=1
+        return dfs(1, counter)
 # leetcode submit region end(Prohibit modification and deletion)

script/[110]平衡二叉树.py

@@ -37,7 +37,7 @@
 #  树中的节点数在范围 [0, 5000] 内 
 #  -10⁴ <= Node.val <= 10⁴ 
 #  
-#  Related Topics 树 深度优先搜索 二叉树 👍 1075 👎 0
+#  Related Topics 树 深度优先搜索 二叉树 👍 1079 👎 0
 
 
 # leetcode submit region begin(Prohibit modification and deletion)
@@ -49,4 +49,21 @@
 #         self.right = right
 class Solution:
     def isBalanced(self, root: TreeNode) -> bool:
+        def dfs(root):
+            if not root:
+                return 0
+            left = dfs(root.left)
+            right = dfs(root.right)
+            if left ==-1 or right==-1:
+                return -1
+            elif abs(right-left)>1:
+                return -1
+            else:
+                return max(left,right)+1
+        result = dfs(root)
+        if result==-1:
+            return False
+        else:
+            return True
+
 # leetcode submit region end(Prohibit modification and deletion)

script/[114]二叉树展开为链表.py

@@ -55,4 +55,16 @@ def flatten(self, root: TreeNode) -> None:
         """
         Do not return anything, modify root in-place instead.
         """
+        pre = None
+        def dfs(root):
+            nonlocal pre
+            if not root:
+                return None
+            dfs(root.right)
+            dfs(root.left)
+            root.left = None
+            root.right= pre
+            pre = root
+        dfs(root)
+        return pre
 # leetcode submit region end(Prohibit modification and deletion)

script/[129]求根节点到叶节点数字之和.py

@@ -58,4 +58,17 @@
 #         self.right = right
 class Solution:
     def sumNumbers(self, root: TreeNode) -> int:
+        total = 0
+        def dfs(root, path):
+            nonlocal total
+            if not root.left and not root.right:
+                path = 10*path + root.val
+                total+=path
+                return
+            if root.left:
+                dfs(root.left, 10*path+root.val)
+            if root.right:
+                dfs(root.right, 10*path+root.val)
+        dfs(root, 0)
+        return total
 # leetcode submit region end(Prohibit modification and deletion)

script/[236]二叉树的最近公共祖先.py

@@ -39,7 +39,7 @@
 #  p != q 
 #  p 和 q 均存在于给定的二叉树中。 
 #  
-#  Related Topics 树 深度优先搜索 二叉树 👍 1850 👎 0
+#  Related Topics 树 深度优先搜索 二叉树 👍 1854 👎 0
 
 
 # leetcode submit region begin(Prohibit modification and deletion)
@@ -52,5 +52,20 @@
 
 class Solution:
     def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
+        def dfs(root):
+            #返回的是节点
+            if not root:
+                return None
+            if root==p or root==q:
+                return root
+            left = dfs(root.left)
+            right =dfs(root.right)
+            if left and right:
+                return root
+            elif left:
+                return left
+            else:
+                return right
+        return dfs(root)
 
 # leetcode submit region end(Prohibit modification and deletion)

script/[429]N 叉树的层序遍历.py

@@ -0,0 +1,65 @@
+# 给定一个 N 叉树，返回其节点值的层序遍历。（即从左到右，逐层遍历）。 
+# 
+#  树的序列化输入是用层序遍历，每组子节点都由 null 值分隔（参见示例）。 
+# 
+#  
+# 
+#  示例 1： 
+# 
+#  
+# 
+#  
+# 输入：root = [1,null,3,2,4,null,5,6]
+# 输出：[[1],[3,2,4],[5,6]]
+#  
+# 
+#  示例 2： 
+# 
+#  
+# 
+#  
+# 输入：root = [1,null,2,3,4,5,null,null,6,7,null,8,null,9,10,null,null,11,null,12,
+# null,13,null,null,14]
+# 输出：[[1],[2,3,4,5],[6,7,8,9,10],[11,12,13],[14]]
+#  
+# 
+#  
+# 
+#  提示： 
+# 
+#  
+#  树的高度不会超过 1000 
+#  树的节点总数在 [0, 10^4] 之间 
+#  
+#  Related Topics 树 广度优先搜索 👍 304 👎 0
+
+
+# leetcode submit region begin(Prohibit modification and deletion)
+"""
+# Definition for a Node.
+class Node:
+    def __init__(self, val=None, children=None):
+        self.val = val
+        self.children = children
+"""
+
+class Solution:
+    def levelOrder(self, root: 'Node') -> List[List[int]]:
+        if not root:
+            return []
+        result = []
+        stack = [root]
+        while stack:
+            l = len(stack)
+            tmp = []
+            for i in range(l):
+                node= stack.pop(0)
+                tmp.append(node.val)
+                for i in node.children:
+                    stack.append(i)
+            result.append(tmp)
+        return result
+
+
+        
+# leetcode submit region end(Prohibit modification and deletion)

script/[450]删除二叉搜索树中的节点.py

@@ -65,4 +65,28 @@
 #         self.right = right
 class Solution:
     def deleteNode(self, root: Optional[TreeNode], key: int) -> Optional[TreeNode]:
+        def dfs(root):
+            if not root:
+                return None
+            if root.val ==key:
+                if not root.left and not root.right:
+                    return None
+                elif not root.left:
+                    return root.right
+                elif not root.right:
+                    return root.left
+                else:
+                    cur = root.right
+                    left = root.left
+                    while cur.left:
+                        cur = cur.left
+                    cur.left = left
+                    return root.right
+            elif root.val < key:
+                root.right = dfs(root.right)
+            else:
+                root.left =dfs(root.left )
+            return root
+        return dfs(root)
+
 # leetcode submit region end(Prohibit modification and deletion)

script/[543]二叉树的直径.py

@@ -0,0 +1,44 @@
+# 给定一棵二叉树，你需要计算它的直径长度。一棵二叉树的直径长度是任意两个结点路径长度中的最大值。这条路径可能穿过也可能不穿过根结点。 
+# 
+#  
+# 
+#  示例 : 
+# 给定二叉树 
+# 
+#            1
+#          / \
+#         2   3
+#        / \     
+#       4   5    
+#  
+# 
+#  返回 3, 它的长度是路径 [4,2,1,3] 或者 [5,2,1,3]。 
+# 
+#  
+# 
+#  注意：两结点之间的路径长度是以它们之间边的数目表示。 
+#  Related Topics 树 深度优先搜索 二叉树 👍 1097 👎 0
+
+
+# leetcode submit region begin(Prohibit modification and deletion)
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class Solution:
+    def diameterOfBinaryTree(self, root: Optional[TreeNode]) -> int:
+        maxl = 0
+        def dfs(root):
+            nonlocal maxl
+            if not root:
+                return 0
+            left = dfs(root.left)
+            right =dfs(root.right)
+            maxl = max(maxl, left+right)
+            return max(left, right)+1
+        dfs(root)
+        return maxl
+
+# leetcode submit region end(Prohibit modification and deletion)

script/[559]N 叉树的最大深度.py

@@ -0,0 +1,59 @@
+# 给定一个 N 叉树，找到其最大深度。 
+# 
+#  最大深度是指从根节点到最远叶子节点的最长路径上的节点总数。 
+# 
+#  N 叉树输入按层序遍历序列化表示，每组子节点由空值分隔（请参见示例）。 
+# 
+#  
+# 
+#  示例 1： 
+# 
+#  
+# 
+#  
+# 输入：root = [1,null,3,2,4,null,5,6]
+# 输出：3
+#  
+# 
+#  示例 2： 
+# 
+#  
+# 
+#  
+# 输入：root = [1,null,2,3,4,5,null,null,6,7,null,8,null,9,10,null,null,11,null,12,
+# null,13,null,null,14]
+# 输出：5
+#  
+# 
+#  
+# 
+#  提示： 
+# 
+#  
+#  树的深度不会超过 1000 。 
+#  树的节点数目位于 [0, 10⁴] 之间。 
+#  
+#  Related Topics 树 深度优先搜索 广度优先搜索 👍 293 👎 0
+
+
+# leetcode submit region begin(Prohibit modification and deletion)
+"""
+# Definition for a Node.
+class Node:
+    def __init__(self, val=None, children=None):
+        self.val = val
+        self.children = children
+"""
+
+class Solution:
+    def maxDepth(self, root: 'Node') -> int:
+        def dfs(root):
+            if not root:
+                return 0
+            depth = 0
+            for child in root.children:
+                depth = max(depth, dfs(child))
+            return depth+1
+        return dfs(root )
+        
+# leetcode submit region end(Prohibit modification and deletion)