2019.12.5

Author: Terry-Ma

102-二叉树的层次遍历.cpp

@@ -0,0 +1,19 @@
+class Solution {
+public:
+    void levelorder(vector<vector<int>>& myvector, TreeNode* root, int depth){
+        if(root){
+            if(depth >= myvector.size())
+                myvector.push_back(vector<int> {});
+
+            myvector[depth].push_back(root->val);
+            levelorder(myvector, root->left, depth + 1);
+            levelorder(myvector, root->right, depth + 1);
+        }
+    }
+
+    vector<vector<int>> levelOrder(TreeNode* root) {
+        vector<vector<int>> result;
+        levelorder(result, root, 0);
+        return result;
+    }
+};

102-二叉树的层次遍历.py

@@ -0,0 +1,19 @@
+class Solution:
+    def levelOrder(self, root: TreeNode) -> List[List[int]]:
+        import queue
+
+        result = []
+        myqueue = queue.Queue()
+        myqueue.put((root, 0))
+         
+        while not myqueue.empty():
+            node, depth = myqueue.get()
+            if node:
+                if depth > len(result) - 1:
+                    result.append([node.val])
+                else:
+                    result[depth].append(node.val)
+                myqueue.put((node.left, depth + 1))
+                myqueue.put((node.right, depth + 1))
+        
+        return result

104-二叉树的最大深度.cpp

@@ -0,0 +1,24 @@
+class Solution {
+public:
+    int maxDepth(TreeNode* root) {
+
+        stack<pair<TreeNode*, int>> mystack;
+        TreeNode* node = root;
+        int depth = 0;
+        int max_depth = 0;
+        mystack.push(pair<TreeNode*, int>(root, 0));
+
+        while(!mystack.empty()){
+            node = mystack.top().first;
+            depth = mystack.top().second;
+            mystack.pop();
+            max_depth = max(depth, max_depth);
+            if(!node)
+                continue;
+            mystack.push(pair<TreeNode*, int>(node->left, depth + 1));
+            mystack.push(pair<TreeNode*, int>(node->right, depth + 1));
+        }
+
+        return max_depth;
+    }
+};

104-二叉树的最大深度.py

@@ -0,0 +1,15 @@
+class Solution:
+    def maxDepth(self, root: TreeNode) -> int:
+        import queue
+        
+        myqueue = queue.Queue()
+        myqueue.put((root, 0))
+
+        while not myqueue.empty():
+            node, depth = myqueue.get()
+            if not node:
+                continue
+            myqueue.put((node.left, depth + 1))
+            myqueue.put((node.right, depth + 1))
+
+        return depth

105-从中序与后序遍历序列构建二叉树.cpp

@@ -0,0 +1,21 @@
+class Solution {
+public:
+    TreeNode* build_tree(vector<int>& inorder, vector<int>& postorder, int a, int b, int c, int d){
+        if(a == b)
+            return NULL;
+
+        int i = a - 1;
+        while(inorder[++i] != postorder[d - 1]);
+
+        TreeNode* root = new TreeNode(postorder[d - 1]);
+
+        root->left = build_tree(inorder, postorder, a, i, c, c + i - a);
+        root->right = build_tree(inorder, postorder, i + 1, b, c + i - a, d - 1);
+
+        return root;
+    }
+    
+    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
+        return build_tree(inorder, postorder, 0, inorder.size(), 0, postorder.size());
+    }
+};

105-从中序与后序遍历序列构建二叉树.py

@@ -0,0 +1,16 @@
+class Solution:
+    def build_tree(self, inorder, postorder, a, b, c, d):
+        if a == b:
+            return None
+
+        i = inorder.index(postorder[d - 1])
+
+        root = TreeNode(postorder[d - 1])
+
+        root.left = self.build_tree(inorder, postorder, a, i, c, c + i - a)
+        root.right = self.build_tree(inorder, postorder, i + 1, b, c + i - a, d - 1)
+
+        return root
+
+    def buildTree(self, inorder: List[int], postorder: List[int]) -> TreeNode:
+        return self.build_tree(inorder, postorder, 0, len(inorder), 0, len(postorder))

105-从前序与中序遍历序列构建二叉树.cpp

@@ -0,0 +1,21 @@
+class Solution {
+public:
+    TreeNode* build_tree(vector<int>& preorder, vector<int>& inorder, int a, int b, int c, int d){
+        if(a == b)
+            return NULL;
+        
+        TreeNode* root = new TreeNode(preorder[a]);
+
+        int i = c - 1;
+        while(inorder[++i] != preorder[a]);
+
+        root->left = build_tree(preorder, inorder, a + 1, a + i - c + 1, c, i);
+        root->right = build_tree(preorder, inorder, a + i - c + 1, b, i + 1, d);
+
+        return root;
+    }
+    
+    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
+        return build_tree(preorder, inorder, 0, preorder.size(), 0, inorder.size());
+    }
+};

105-从前序与中序遍历序列构建二叉树.py

@@ -0,0 +1,13 @@
+class Solution:
+    def buildTree(self, preorder: List[int], inorder: List[int]) -> TreeNode:
+        if not preorder:
+            return None
+        
+        root = TreeNode(preorder[0])
+
+        boundary = inorder.index(preorder[0])
+
+        root.left = self.buildTree(preorder[1:boundary + 1], inorder[:boundary])
+        root.right = self.buildTree(preorder[boundary + 1:], inorder[boundary + 1:])
+
+        return root

108-将有序数组转换为二叉搜索树.cpp

@@ -0,0 +1,24 @@
+class Solution {
+public:
+    TreeNode* sorted_array_to_bst(vector<int>& nums, int left, int right){
+        if(left > right)
+            return NULL;
+
+        if(left == right){
+            TreeNode* root = new TreeNode(nums[left]);
+            return root;
+        }
+
+        int middle = left + (right - left) / 2;
+        TreeNode* root = new TreeNode(nums[middle]);
+
+        root->left = sorted_array_to_bst(nums, left, middle - 1);
+        root->right = sorted_array_to_bst(nums, middle + 1, right);
+
+        return root;
+    }
+
+    TreeNode* sortedArrayToBST(vector<int>& nums) {
+        return sorted_array_to_bst(nums, 0, nums.size() - 1);
+    }
+};

108-将有序数组转换为二叉搜索树.py

@@ -0,0 +1,19 @@
+class Solution:
+    def sortedArrayToBST(self, nums: List[int]) -> TreeNode:
+
+        def sorted_array_to_bst(nums, left, right):
+            if left > right:
+                return None
+
+            if left == right:
+                return TreeNode(nums[left])
+            
+            middle = (left + right) // 2
+            root = TreeNode(nums[middle])
+
+            root.left = sorted_array_to_bst(nums, left, middle - 1)
+            root.right = sorted_array_to_bst(nums, middle + 1, right)
+
+            return root
+        
+        return sorted_array_to_bst(nums, 0, len(nums) - 1)