Add C++ solutions for Chapter 11 (Trees)

Author: ongshunping

cpp/Trees/balanced_binary_tree_validation.cpp

@@ -0,0 +1,35 @@
+#include "ds/TreeNode.h"
+using ds::TreeNode;
+
+/**
+ * Definition of TreeNode:
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
+ * };
+ */
+
+bool balancedBinaryTreeValidation(TreeNode* root) {
+    return getHeightImbalance(root) != -1;
+}
+
+int getHeightImbalance(TreeNode* node) {
+    // Base case: if the node is null, its height is 0.
+    if (!node)
+        return 0;
+    // Recursively get the height of the left and right subtrees. If
+    // either subtree is imbalanced, propagate -1 up the tree.
+    int leftHeight = getHeightImbalance(node->left);
+    int rightHeight = getHeightImbalance(node->right);
+    if (leftHeight == -1 || rightHeight == -1)
+        return -1;
+    // If the current node's subtree is imbalanced
+    // (height difference > 1), return -1.
+    if (abs(leftHeight - rightHeight) > 1)
+        return -1;
+    // Return the height of the current subtree.
+    return 1 + std::max(leftHeight, rightHeight);
+}

cpp/Trees/binary_search_tree_validation.cpp

@@ -0,0 +1,36 @@
+#include <limits>
+#include "ds/TreeNode.h"
+using ds::TreeNode;
+
+/**
+ * Definition of TreeNode:
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
+ * };
+ */
+
+bool binarySearchTreeValidation(TreeNode* root) {
+    // Start validation at the root node. The root node can contain any 
+    // value, so set the initial lower and upper bounds to -infinity and 
+    // +infinity, respectively.
+    return isWithinBounds(root, std::numeric_limits<int>::min(), std::numeric_limits<int>::max());
+}
+
+bool isWithinBounds(TreeNode* node, int lowerBound, int upperBound) {
+    // Base case: if the node is null, it satisfies the BST condition.
+    if (!node)
+        return true;
+    // If the current node's value is not within the valid bounds, this 
+    // tree is not a valid BST.
+    if (!(lowerBound < node->val && node->val < upperBound))
+        return false;
+    // If the left subtree isn't a BST, this tree isn't a BST.
+    if (!isWithinBounds(node->left, lowerBound, node->val))
+        return false;
+    // Otherwise, return true if the right subtree is also a BST.
+    return isWithinBounds(node->right, node->val, upperBound);
+}

cpp/Trees/binary_tree_columns.cpp

@@ -0,0 +1,52 @@
+#include <vector>
+#include <unordered_map>
+#include <queue>
+#include <utility>
+#include <algorithm>
+#include "ds/TreeNode.h"
+using ds::TreeNode;
+
+/**
+ * Definition of TreeNode:
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
+ * };
+ */
+
+std::vector<std::vector<int>> binaryTreeColumns(TreeNode* root) {
+    if (!root)
+        return {};
+    std::unordered_map<int, std::vector<int>> columnMap;
+    int leftmostColumn = 0, rightmostColumn = 0;
+    std::queue<std::pair<TreeNode*, int>> queue;
+    queue.push({root, 0});
+    while (!queue.empty()) {
+        TreeNode* node = queue.front().first;
+        int column = queue.front().second;
+        queue.pop();
+        if (node) {
+            // Add the current node's value to its corresponding list in the hash
+            // map.
+            columnMap[column].push_back(node->val);
+            leftmostColumn = std::min(leftmostColumn, column);
+            rightmostColumn = std::max(rightmostColumn, column);
+            // Add the current node's children to the queue with their respective
+            // column ids.
+            queue.push({node->left, column - 1});
+            queue.push({node->right, column + 1});
+        }
+    }
+    // Construct the output list by collecting values from each column in the hash   
+    // map in the correct order. 
+    std::vector<std::vector<int>> res;
+    for (int i = leftmostColumn; i <= rightmostColumn; i++) {
+        if (columnMap.count(i)) {
+            res.push_back(columnMap[i]);
+        }
+    }
+    return res;
+}

cpp/Trees/binary_tree_symmetry.cpp

@@ -0,0 +1,37 @@
+#include "ds/TreeNode.h"
+using ds::TreeNode;
+
+/**
+ * Definition of TreeNode:
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
+ * };
+ */
+
+bool binaryTreeSymmetry(TreeNode* root) {
+    if (!root)
+        return true;  
+    return compareTrees(root->left, root->right);
+}
+
+bool compareTrees(TreeNode* node1, TreeNode* node2) {
+    // Base case: if both nodes are null, they're symmetric.
+    if (!node1 && !node2)
+        return true;
+    // If one node is null and the other isn't, they aren't symmetric.
+    if (!node1 || !node2)
+        return false;
+    // If the values of the current nodes don't match, trees aren't symmetric.
+    if (node1->val != node2->val)
+        return false;
+    // Compare the 'node1's left subtree with 'node2's right subtree. If these 
+    // aren't symmetric, the whole tree is not symmetric.
+    if (!compareTrees(node1->left, node2->right))
+        return false;
+    // Compare the 'node1's right subtree with 'node2's left subtree. 
+    return compareTrees(node1->right, node2->left);
+}

cpp/Trees/build_binary_tree.cpp

@@ -0,0 +1,47 @@
+#include <vector>
+#include <unordered_map>
+#include "ds/TreeNode.h"
+using ds::TreeNode;
+
+/**
+ * Definition of TreeNode:
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode* left;
+ *     TreeNode* right;
+ *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x, TreeNode* left, TreeNode* right) : val(x), left(left), right(right) {}
+ * };
+ */
+
+TreeNode* buildBinaryTree(std::vector<int>& preorder, std::vector<int>& inorder) {
+    // Populate the hash map with the inorder values and their indexes.
+    std::unordered_map<int, int> inorderIndexesMap;
+    for (int i = 0; i < inorder.size(); i++) {
+        inorderIndexesMap[inorder[i]] = i;
+    }
+    // Build the tree and return its root node.
+    int preorderIndex = 0;
+    return buildSubtree(0, inorder.size() - 1, preorder, inorder, preorderIndex, inorderIndexesMap);
+}
+
+TreeNode* buildSubtree(int left, int right, std::vector<int>& preorder, std::vector<int>& inorder,
+                       int& preorderIndex, std::unordered_map<int, int>& inorderIndexesMap) {
+    // Base case: if no elements are in this range, return nullptr.
+    if (left > right) {
+        return nullptr;
+    }
+    int val = preorder[preorderIndex];
+    // Set 'inorder_index' to the index of the same value pointed at by
+    // 'preorder_index'. 
+    int inorderIndex = inorderIndexesMap[val];
+    TreeNode* node = new TreeNode(val);
+    // Advance 'preorder_index' so it points to the value of the next
+    // node to be created.
+    preorderIndex++;
+    // Build the left and right subtrees and connect them to the current
+    // node.
+    node->left = buildSubtree(left, inorderIndex - 1, preorder, inorder, preorderIndex, inorderIndexesMap);
+    node->right = buildSubtree(inorderIndex + 1, right, preorder, inorder, preorderIndex, inorderIndexesMap);
+    return node;
+}

cpp/Trees/invert_binary_tree_iterative.cpp

@@ -0,0 +1,34 @@
+#include <stack>
+#include <algorithm>
+#include "ds/TreeNode.h"
+using ds::TreeNode;
+
+/**
+ * Definition of TreeNode:
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
+ * };
+ */
+
+TreeNode* invertBinaryTreeIterative(TreeNode* root) {
+    if (!root)
+        return nullptr;
+    std::stack<TreeNode*> stack;
+    stack.push(root);
+    while (!stack.empty()) {
+        TreeNode* node = stack.top();
+        stack.pop();
+        // Swap the left and right subtrees of the current node.
+        std::swap(node->left, node->right);
+        // Push the left and right subtrees onto the stack.
+        if (node->left)
+            stack.push(node->left);
+        if (node->right)
+            stack.push(node->right);
+    }
+    return root;
+}

cpp/Trees/invert_binary_tree_recursive.cpp

@@ -0,0 +1,26 @@
+#include <algorithm>
+#include "ds/TreeNode.h"
+using ds::TreeNode;
+
+/**
+ * Definition of TreeNode:
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
+ * };
+ */
+
+TreeNode* invertBinaryTreeRecursive(TreeNode* root) {
+    // Base case: If the node is null, there's nothing to invert.
+    if (!root)
+        return nullptr;
+    // Swap the left and right subtrees of the current node.
+    std::swap(root->left, root->right);
+    // Recursively invert the left and right subtrees.
+    invertBinaryTreeRecursive(root->left);
+    invertBinaryTreeRecursive(root->right);
+    return root;
+}

cpp/Trees/kth_smallest_number_in_BST_iterative.cpp

@@ -0,0 +1,41 @@
+#include <stack>
+#include "ds/TreeNode.h"
+using ds::TreeNode;
+
+/**
+ * Definition of TreeNode:
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
+ * };
+ */
+
+int kthSmallestNumberInBSTIterative(TreeNode* root, int k) {
+    std::stack<TreeNode*> stack;
+    TreeNode* node = root;
+    while (!stack.empty() || node) {
+        // Move to the leftmost node and add nodes to the stack as we go so they
+        // can be processed in future iterations.
+        while (node) {
+            stack.push(node);
+            node = node->left;
+        }
+        // Pop the top node from the stack to process it, and decrement 'k'.
+        node = stack.top();
+        stack.pop();
+        k--;
+        // If we have processed 'k' nodes, return the value of the 'k'th smallest
+        // node.
+        if (k == 0) {
+            return node->val;
+        }
+        // Move to the right subtree.
+        node = node->right;
+    }
+    // If 'k' is larger than the number of nodes in the tree, 
+    // return -1 or handle as needed.
+    return -1;
+}

cpp/Trees/kth_smallest_number_in_BST_recursive.cpp

@@ -0,0 +1,30 @@
+#include <vector>
+#include "ds/TreeNode.h"
+using ds::TreeNode;
+
+/**
+ * Definition of TreeNode:
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
+ * };
+ */
+
+int kthSmallestNumberInBSTRecursive(TreeNode* root, int k) {
+    std::vector<int> sortedList = inorder(root);
+    return sortedList[k - 1];
+}
+
+// Inorder traversal function to attain a sorted list of nodes from the BST.
+std::vector<int> inorder(TreeNode* node) {
+    if (!node)
+        return {};
+    std::vector<int> left = inorder(node->left);
+    left.push_back(node->val);
+    std::vector<int> right = inorder(node->right);
+    left.insert(left.end(), right.begin(), right.end());
+    return left;
+}

cpp/Trees/lowest_common_ancestor.cpp

@@ -0,0 +1,36 @@
+#include "ds/TreeNode.h"
+using ds::TreeNode;
+
+/**
+ * Definition of TreeNode:
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
+ * };
+ */
+
+TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
+    TreeNode* lca = nullptr;
+    dfs(root, p, q, lca);
+    return lca;
+}
+
+bool dfs(TreeNode* node, TreeNode* p, TreeNode* q, TreeNode*& lca) {
+    // Base case: a null node is neither 'p' nor 'q'.
+    if (!node)
+        return false;
+    bool nodeIsPOrQ = (node == p || node == q);
+    // Recursively determine if the left and right subtrees contain 'p' 
+    // or 'q'.
+    bool leftContainsPOrQ = dfs(node->left, p, q, lca);
+    bool rightContainsPOrQ = dfs(node->right, p, q, lca);
+    // If two of the above three variables are true, the current node is 
+    // the LCA.
+    if (nodeIsPOrQ + leftContainsPOrQ + rightContainsPOrQ == 2)
+        lca = node;
+    // Return true if the current subtree contains 'p' or 'q'.
+    return nodeIsPOrQ || leftContainsPOrQ || rightContainsPOrQ;
+}