format filename

Author: HONGJICAI

README.md

@@ -0,0 +1,12 @@
+class Solution {
+public:
+  vector<int> twoSum(vector<int> &nums, int target) {
+    unordered_map<int, int> map;
+    for (int i = 0; i < nums.size(); ++i) {
+      if (auto it = map.find(target - nums[i]); it != map.end())
+        return {it->second, i};
+      map[nums[i]] = i;
+    }
+    return {};
+  }
+};

cpp/1.TwoSum.cpp

@@ -0,0 +1,19 @@
+// recursion-3ms.cpp
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+class Solution {
+public:
+  bool isSameTree(TreeNode *p, TreeNode *q) {
+    if (p == NULL || q == NULL)
+      return p == q;
+    return p->val == q->val && isSameTree(p->left, q->left) &&
+           isSameTree(p->right, q->right);
+  }
+};

cpp/1.cpp

@@ -0,0 +1,18 @@
+class Solution { // 8ms  99.37%
+public:
+  vector<string> commonChars(vector<string> &A) {
+    vector<int> arr(26, numeric_limits<int>::max());
+    vector<string> res;
+    for (auto &s : A) {
+      array<int, 26> cnt = {};
+      for (auto c : s)
+        ++cnt[c - 'a'];
+      for (auto i = 0; i < 26; ++i)
+        arr[i] = min(arr[i], cnt[i]);
+    }
+    for (auto i = 0; i < 26; ++i)
+      while (arr[i] != numeric_limits<int>::max() && arr[i]-- > 0)
+        res.push_back(string(1, i + 'a'));
+    return res;
+  }
+};

cpp/100.SameTree/recursion-3ms.cpp

@@ -0,0 +1,37 @@
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+class Solution {
+  // Runtime: 4 ms, faster than 96.40% of C++ online submissions for Construct
+  // Binary Search Tree from Preorder Traversal. Memory Usage: 8.7 MB, less
+  // than 97.42% of C++ online submissions for Construct Binary Search Tree from
+  // Preorder Traversal.
+public:
+  TreeNode *bstFromPreorder(vector<int> &preorder) {
+    if (not preorder.size())
+      return nullptr;
+    auto r = new TreeNode(preorder[0]);
+    auto now = r;
+    vector<TreeNode *> st;
+    for (int i = 1; i < preorder.size(); ++i) {
+      auto t = preorder[i];
+      if (t < now->val) {
+        st.push_back(now);
+        now = now->left = new TreeNode(t);
+      } else {
+        while (st.size() && t > st.back()->val) {
+          now = st.back();
+          st.pop_back();
+        }
+        now = now->right = new TreeNode(t);
+      }
+    }
+    return r;
+  }
+};

cpp/100.cpp

@@ -0,0 +1,13 @@
+class Solution { // 0ms iteration
+public:
+  int bitwiseComplement(int N) {
+    if (!N)
+      return 1;
+    int res = 0, time = 0;
+    while (N) {
+      res += (!(N & 1)) << time++;
+      N >>= 1;
+    }
+    return res;
+  }
+};

cpp/1002.FindCommonCharacters.cpp

@@ -0,0 +1,36 @@
+// iteration.cpp
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+class Solution {
+public:
+  bool isSymmetric(TreeNode *root) {
+    if (root == NULL)
+      return 1;
+    queue<TreeNode *> qe1, qe2;
+    qe1.push(root->left);
+    qe2.push(root->right);
+    while (!qe1.empty() && !qe2.empty()) {
+      TreeNode *r1 = qe1.front();
+      TreeNode *r2 = qe2.front();
+      qe1.pop();
+      qe2.pop();
+      if (r1 && r2) {
+        if (r1->val != r2->val)
+          return 0;
+        qe1.push(r1->left);
+        qe1.push(r1->right);
+        qe2.push(r2->right);
+        qe2.push(r2->left);
+      } else if (r1 != r2)
+        return 0;
+    }
+    return 1;
+  }
+};

cpp/1002.cpp

@@ -0,0 +1,27 @@
+// preOrderReversion-3ms.cpp
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+class Solution {
+public:
+  vector<vector<int>> levelOrder(TreeNode *root) {
+    vector<vector<int>> result;
+    preOrder(0, root, result);
+    return result;
+  }
+  void preOrder(int i, TreeNode *root, vector<vector<int>> &nums) {
+    if (root == NULL)
+      return;
+    if (nums.size() == i)
+      nums.push_back(vector<int>());
+    nums[i].push_back(root->val);
+    preOrder(i + 1, root->left, nums);
+    preOrder(i + 1, root->right, nums);
+  }
+};

cpp/1008.ConstructBinarySearchTreeFromPreorderTraversal.cpp

@@ -0,0 +1,15 @@
+class Solution { // Runtime: 4 ms, faster than 97.26% of C++ online submissions
+                 // for Remove Outermost Parentheses.
+public:
+  string removeOuterParentheses(string S) {
+    string res;
+    int opened = 0;
+    for (char c : S) {
+      if (c == '(' && opened++)
+        res += c;
+      else if (c == ')' && --opened)
+        res += c;
+    }
+    return res;
+  }
+};