push all

Author: xwk1246

102.binary-tree-level-order-traversal.cpp

@@ -0,0 +1,54 @@
+#include <vector>
+#include <queue>
+using namespace std;
+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 l, TreeNode r) :val(x), left(l), right(r) {}
+};
+/*
+ * @lc app=leetcode id=102 lang=cpp
+ *
+ * [102] Binary Tree Level Order Traversal
+ */
+
+ // @lc code=start
+ /**
+  * 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<vector<int>> levelOrder(TreeNode* root) {
+        vector<vector<int>> out;
+        queue<TreeNode*> q;
+        if (!root)return {};
+        q.push(root);
+        while (!q.empty()) {
+            vector<int>tmp;
+            int size = q.size();
+            for (int i = 0; i < size; i++) {
+                tmp.push_back(q.front()->val);
+                if (q.front()->left != nullptr)
+                    q.push(q.front()->left);
+                if (q.front()->right != nullptr)
+                    q.push(q.front()->right);
+                q.pop();
+            }
+            out.push_back(tmp);
+        }
+        return out;
+    }
+};
+// @lc code=end
+

144.binary-tree-preorder-traversal.cpp

@@ -0,0 +1,36 @@
+#include <vector>
+using namespace std;
+/*
+ * @lc app=leetcode id=144 lang=cpp
+ *
+ * [144] Binary Tree Preorder Traversal
+ */
+
+ // @lc code=start
+ /**
+  * 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> preorderTraversal(TreeNode* root) {
+        vector<int>out;
+        traverse(root, out);
+        return out;
+    }
+    void traverse(TreeNode* root, vector<int>& out) {
+        if (root == nullptr)return;
+        out.push_back(root->val);
+        traverse(root->left, out);
+        traverse(root->right, out);
+    }
+};
+// @lc code=end
+

145.binary-tree-postorder-traversal.cpp

@@ -0,0 +1,36 @@
+/*
+ * @lc app=leetcode id=145 lang=cpp
+ *
+ * [145] Binary Tree Postorder Traversal
+ */
+
+ // @lc code=start
+ /**
+  * 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> postorderTraversal(TreeNode* root) {
+        vector<int>out;
+        traverse(root, out);
+        return out;
+    }
+    void traverse(TreeNode* root, vector<int>& out) {
+        if (root == nullptr)return;
+        traverse(root->left, out);
+        traverse(root->right, out);
+        out.push_back(root->val);
+    }
+
+
+};
+// @lc code=end
+

347.top-k-frequent-elements.cpp

@@ -0,0 +1,45 @@
+#include <vector>
+#include <unordered_map>
+#include <queue>
+
+using namespace std;
+/*
+ * @lc app=leetcode id=347 lang=cpp
+ *
+ * [347] Top K Frequent Elements
+ */
+
+ // @lc code=start
+class Solution {
+    class compare {
+    public:
+        bool operator()(pair<int, int>& a, pair<int, int>& b) {
+            return a.second < b.second;
+        }
+    };
+public:
+    vector<int> topKFrequent(vector<int>& nums, int k) {
+        unordered_map<int, int>numMap;
+        vector< int>out;
+        for (auto i : nums) {
+            numMap[i]++;
+        }
+        priority_queue < pair<int, int>, vector<pair<int, int>>, compare>q;
+        for (auto i : numMap) {
+            q.push(i);
+        }
+        while (k--) {
+            out.push_back(q.top().first);
+            q.pop();
+        }
+        return out;
+    }
+};
+// @lc code=end
+
+int main() {
+    Solution s;
+    vector<int>nums{ 1, 1, 1, 2, 2, 3 };
+    s.topKFrequent(nums, 2);
+    return 0;
+}

94.binary-tree-inorder-traversal.cpp

@@ -0,0 +1,36 @@
+/*
+ * @lc app=leetcode id=94 lang=cpp
+ *
+ * [94] Binary Tree Inorder Traversal
+ */
+
+ // @lc code=start
+ /**
+  * 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> inorderTraversal(TreeNode* root) {
+        vector<int>out;
+        traverse(root, out);
+        return out;
+    }
+    void traverse(TreeNode* root, vector<int>& out) {
+        if (root == nullptr)return;
+        traverse(root->left, out);
+        out.push_back(root->val);
+        traverse(root->right, out);
+    }
+
+
+};
+// @lc code=end
+