add lc medium

lzyrapx · lzyrapx · commit 359761559cfe · 2020-08-18T00:33:39.000+08:00
diff --git a/LeetCode/Medium/0429.cpp b/LeetCode/Medium/0429.cpp
@@ -0,0 +1,46 @@
+/*
+// Definition for a Node.
+class Node {
+public:
+    int val;
+    vector<Node*> children;
+
+    Node() {}
+
+    Node(int _val) {
+        val = _val;
+    }
+
+    Node(int _val, vector<Node*> _children) {
+        val = _val;
+        children = _children;
+    }
+};
+*/
+
+class Solution {
+public:
+    // 给定一个 N 叉树，返回其节点值的层序遍历
+    vector<vector<int>> levelOrder(Node* root) {
+        vector<vector<int>>ans;
+        if(root == NULL) {
+            return ans;
+        }
+        queue<Node*>que;
+        que.push(root);
+        while(!que.empty()) {
+            int sz = que.size();
+            vector<int>path;
+            for(int i = 0; i < sz; i++) {
+                Node* cur = que.front();
+                que.pop();
+                path.push_back(cur -> val);
+                for(int j = 0; j < cur -> children.size(); j++) {
+                    que.push(cur -> children[j]);
+                }
+            }
+            ans.push_back(path);
+        }
+        return ans;
+    }
+};
diff --git a/LeetCode/Medium/0449.cpp b/LeetCode/Medium/0449.cpp
@@ -0,0 +1,41 @@
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+class Codec {
+public:
+    // 序列化和反序列化
+    // Encodes a tree to a single string.
+    string serialize(TreeNode* root) {
+        if(root == NULL) {
+            return "#";
+        }
+        return to_string(root -> val) + " " + serialize(root -> left) + " " + serialize(root -> right);
+    }
+    TreeNode* rebuildTree(stringstream& data) {
+        string str;
+        data >> str;
+        if(str == "#") {
+            return NULL;
+        }
+        TreeNode* node = new TreeNode(stoi(str));
+        node->left = rebuildTree(data);
+        node->right = rebuildTree(data);
+        return node;
+        
+    }
+    // Decodes your encoded data to tree.
+    TreeNode* deserialize(string data) {
+        stringstream ss(data);
+        return rebuildTree(ss);
+    }
+};
+
+// Your Codec object will be instantiated and called as such:
+// Codec codec;
+// codec.deserialize(codec.serialize(root));
diff --git a/LeetCode/Medium/0450.cpp b/LeetCode/Medium/0450.cpp
@@ -0,0 +1,48 @@
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
+ * };
+ */
+class Solution {
+public:
+    // 删除二叉树里的一个节点，然后输出新的二叉树
+    TreeNode* deleteNode(TreeNode* root, int key) {
+        if(root == NULL) {
+            return NULL;
+        }
+        if(root -> val == key) {
+            if(root -> left == NULL && root -> right == NULL) {
+                return NULL;
+            }
+            if(root -> left == NULL) {
+                return root -> right;
+            }
+            if(root -> right == NULL) {
+                return root -> left;
+            }
+            // 将删除节点的左孩子放到删除节点的右孩子的最左面节点的左孩子的位置
+            if(root -> left != NULL && root -> right != NULL) {
+                TreeNode* cur = root -> right;
+                while(cur -> left != NULL) {
+                    cur = cur -> left;
+                }
+                cur -> left = root -> left;
+                root = root -> right;
+                return root;
+            }
+        }
+        if(root -> val > key) {
+            root -> left = deleteNode(root -> left, key);
+        }
+        if(root -> val < key) {
+            root -> right = deleteNode(root -> right, key);
+        }
+        return root;
+    }
+};
diff --git a/LeetCode/Medium/0513.cpp b/LeetCode/Medium/0513.cpp
@@ -0,0 +1,34 @@
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
+ * };
+ */
+class Solution {
+public:
+    // 找到二叉树最后一层最左的节点
+    int findBottomLeftValue(TreeNode* root) {
+        if(root == NULL) {
+            return 0;
+        }
+        queue<TreeNode*>que;
+        que.push(root);
+        while(!que.empty()) {
+            TreeNode* cur = que.front();
+            root = cur;
+            que.pop();
+            if(cur -> right != NULL) {
+                que.push(cur -> right);
+            }
+            if(cur -> left != NULL) {
+                que.push(cur -> left);
+            }
+        }
+        return root -> val;
+    }
+};
diff --git a/LeetCode/Medium/0515.cpp b/LeetCode/Medium/0515.cpp
@@ -0,0 +1,39 @@
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
+ * };
+ */
+class Solution {
+public:
+    vector<int> largestValues(TreeNode* root) {
+        if(root == NULL) {
+            return {};
+        }
+        queue<TreeNode*>que;
+        que.push(root);
+        vector<int>ans;
+        while(!que.empty()) {
+            int n = que.size();
+            int max_val = INT_MIN;
+            for(int i = 0; i < n; i++){
+                TreeNode* cur = que.front();
+                que.pop();
+                max_val = max(max_val, cur -> val);
+                if(cur -> left != NULL) {
+                    que.push(cur -> left);
+                }
+                if(cur -> right != NULL) {
+                    que.push(cur -> right);
+                }
+            }
+            ans.push_back(max_val);
+        }
+        return ans;
+    }
+};
diff --git a/LeetCode/Medium/0623.cpp b/LeetCode/Medium/0623.cpp
@@ -0,0 +1,57 @@
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
+ * };
+ */
+class Solution {
+public:
+    //  给定一个二叉树，根节点为第1层，深度为 1。在其第 d 层追加一行值为 v 的节点。
+    TreeNode* addOneRow(TreeNode* root, int v, int d) {
+        if(root == NULL) {
+            return NULL;
+        }
+        if(d == 1) {
+            TreeNode* node = new TreeNode(v);
+            node -> left = root;
+            return node;
+        }
+        queue<TreeNode*>que;
+        que.push(root);
+        
+        int level = 2;
+        
+        while(!que.empty()) {
+            int sz = que.size();
+            for(int i = 0; i < sz; i++) {
+                TreeNode* cur = que.front(); // 第 d - 1 层
+                que.pop();
+                
+                if(d == level) {
+                    // 当前层指向新加的层，先处理左边，再处理右边
+                    TreeNode* tmp = cur -> left;
+                    cur -> left = new TreeNode(v);
+                    cur -> left -> left = tmp;
+                    
+                    tmp = cur -> right;
+                    cur -> right = new TreeNode(v);
+                    cur -> right -> right = tmp;
+                }
+                
+                if(cur -> left != NULL) {
+                    que.push(cur -> left);
+                }
+                if(cur -> right != NULL) {
+                    que.push(cur -> right);
+                }
+            }
+            level++;
+        }
+        return root;
+    }
+};
diff --git a/LeetCode/Medium/0652.cpp b/LeetCode/Medium/0652.cpp
@@ -0,0 +1,33 @@
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
+ * };
+ */
+class Solution {
+public:
+    // 给你一棵而测试，找到所有重复了的子树，同类型的就输出其中一个即可
+    vector<TreeNode*> findDuplicateSubtrees(TreeNode* root) {
+        vector<TreeNode*>ans;
+        unordered_map<string, int>mp;
+        dfs(ans, mp, root);
+        return ans;
+    }
+    string dfs(vector<TreeNode*>&ans, unordered_map<string, int>&mp, TreeNode* root) {
+        if(root == NULL) {
+            return "";
+        }
+        string str;
+        str = to_string(root -> val) + " " + dfs(ans, mp, root -> left) + " " + dfs(ans, mp, root -> right);
+        if(mp[str] == 1) {
+            ans.push_back(root);
+        }
+        mp[str]++;
+        return str;
+    }
+};
diff --git a/LeetCode/Medium/0797 (dfs).cpp b/LeetCode/Medium/0797 (dfs).cpp
@@ -0,0 +1,20 @@
+class Solution {
+public:
+    // 给你 N 个点的有向图，输出所有从 0 - N-1 的路径
+    vector<vector<int>> allPathsSourceTarget(vector<vector<int>>& graph) {
+        vector<int>path;
+        vector<vector<int>>ans;
+        dfs(ans, path, graph,0);
+        return ans;
+    }
+    void dfs(vector<vector<int>>&ans, vector<int>&path, vector<vector<int>>&graph, int node) {
+        path.push_back(node);
+        if(node == graph.size() - 1) {
+            ans.push_back(path);
+        }
+        for(auto e: graph[node]) {
+            dfs(ans, path, graph, e);
+        }
+        path.pop_back();
+    }
+};
diff --git a/LeetCode/Medium/0814.cpp b/LeetCode/Medium/0814.cpp
@@ -0,0 +1,32 @@
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
+ * };
+ */
+class Solution {
+public:
+    // 输出移除了所有不包含 1 的子树的原二叉树。
+    TreeNode* pruneTree(TreeNode* root) {
+        if(root == NULL) {
+            return NULL;
+        }
+        TreeNode* left = pruneTree(root -> left);
+        TreeNode* right = pruneTree(root -> right);
+        if(left == NULL && right == NULL && root -> val == 0) {
+            // ignore this node
+            return NULL;
+        }
+        else {
+            root -> left = left;
+            root -> right = right;
+            return root;
+        }
+        
+    }
+};
diff --git a/LeetCode/Medium/0932.cpp b/LeetCode/Medium/0932.cpp
