Sync LeetCode submission Runtime - 4 ms (85.25%), Memory - 65.8 MB (38.96%)

Author: koralkulacoglu

LeetCode/1285-balance-a-binary-search-tree/README.md

@@ -0,0 +1,27 @@
+<p>Given the <code>root</code> of a binary search tree, return <em>a <strong>balanced</strong> binary search tree with the same node values</em>. If there is more than one answer, return <strong>any of them</strong>.</p>
+
+<p>A binary search tree is <strong>balanced</strong> if the depth of the two subtrees of every node never differs by more than <code>1</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/08/10/balance1-tree.jpg" style="width: 500px; height: 319px;" />
+<pre>
+<strong>Input:</strong> root = [1,null,2,null,3,null,4,null,null]
+<strong>Output:</strong> [2,1,3,null,null,null,4]
+<b>Explanation:</b> This is not the only correct answer, [3,1,4,null,2] is also correct.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2021/08/10/balanced2-tree.jpg" style="width: 224px; height: 145px;" />
+<pre>
+<strong>Input:</strong> root = [2,1,3]
+<strong>Output:</strong> [2,1,3]
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li>The number of nodes in the tree is in the range <code>[1, 10<sup>4</sup>]</code>.</li>
+	<li><code>1 &lt;= Node.val &lt;= 10<sup>5</sup></code></li>
+</ul>

LeetCode/1285-balance-a-binary-search-tree/solution.cpp

@@ -0,0 +1,37 @@
+/**
+ * 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 {
+    vector<int> vals;
+    void dfs(TreeNode* node) {
+        if (node == nullptr) return;
+        dfs(node->left);
+        vals.push_back(node->val);
+        dfs(node->right);
+    }
+
+    TreeNode* construct(int l, int r) {
+        if (l > r) return nullptr;
+        int m = (l + r) / 2;
+        TreeNode* root = new TreeNode(vals[m]);
+        root->left = construct(l, m-1);
+        root->right = construct(m+1, r);
+        return root;
+    }
+
+public:
+    TreeNode* balanceBST(TreeNode* root) {
+        vals.clear();
+        dfs(root);
+        root = construct(0, vals.size()-1);
+        return root;
+    }
+};