add Day13

Jongeun/Day13/105_ConstructBinaryTreefromPreorderandInorderTraversal.cpp

@@ -0,0 +1,66 @@
+/**
+ * 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 *buildTree(vector<int> &preorder, vector<int> &inorder)
+    {
+        int m = 0;
+        int i = 0;
+        while (preorder[0] != inorder[m])
+        {
+            m++;
+        }
+        // l : range of  my left subtree
+        // r : range of my right subtree
+        TreeNode *node = _buildTree(preorder, inorder, 0, m, inorder.size() - 1, i);
+        return node;
+    }
+
+    TreeNode *_buildTree(vector<int> &preorder, vector<int> &inorder, int l, int m, int r, int &i)
+    {
+        TreeNode *node = new TreeNode(preorder[i]);
+        TreeNode *left = nullptr;
+        TreeNode *right = nullptr;
+
+        i++;
+
+        // check if it is in left subtree
+        int tempt = m - 1;
+        while (tempt >= l && preorder[i] != inorder[tempt])
+        {
+            tempt--;
+        }
+        if (tempt >= l)
+        {
+            // in the left subtree
+            left = _buildTree(preorder, inorder, l, tempt, m - 1, i);
+        }
+
+        // check if it is in the right subtree
+        tempt = m + 1;
+        while (tempt <= r && preorder[i] != inorder[tempt])
+        {
+            tempt++;
+        }
+        if (tempt <= r)
+        {
+            // in the right subtree
+            right = _buildTree(preorder, inorder, m + 1, tempt, r, i);
+        }
+
+        node->left = left;
+        node->right = right;
+
+        return node;
+    }
+};

Jongeun/Day13/124_BinaryTreeMaximumPathSum.cpp

@@ -0,0 +1,67 @@
+/**
+ * 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 maxPathSum(TreeNode *root)
+    {
+        int max = INT_MIN;
+        _maxPathSum(root, max);
+        return max;
+    }
+
+    int _maxPathSum(TreeNode *node, int &max)
+    {
+        if (node == nullptr)
+        {
+            return 0;
+        }
+
+        int left = _maxPathSum(node->left, max);
+        int right = _maxPathSum(node->right, max);
+
+        int win = std::max(left, right);
+
+        // set the Max
+        int temptMax = win;
+        if (left + right > win)
+        {
+            // combine the both path
+            temptMax = left + right;
+        }
+
+        // check if it should the child path
+        if (temptMax > 0)
+        {
+            temptMax = temptMax + node->val;
+        }
+        else
+        {
+            temptMax = node->val;
+        }
+
+        if (temptMax > max)
+        {
+            max = temptMax;
+        }
+
+        // return the node->val or node->val + win
+        if (win > 0)
+        {
+            return win + node->val;
+        }
+        else
+        {
+            return node->val;
+        }
+    }
+};

Jongeun/Day13/230_KthSmallestElementInABST.cpp

@@ -0,0 +1,50 @@
+/**
+ * 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 kthSmallest(TreeNode *root, int k)
+    {
+        int order{0};
+        return _kthSmallest(root, k, order);
+    }
+
+    int _kthSmallest(TreeNode *node, int k, int &order)
+    {
+
+        if (node == nullptr)
+        {
+            return -1;
+        }
+
+        int l = _kthSmallest(node->left, k, order);
+
+        order++;
+        if (order == k)
+        {
+            return node->val;
+        }
+
+        int r = _kthSmallest(node->right, k, order);
+
+        if (l != -1)
+        {
+            return l;
+        }
+        else if (r != -1)
+        {
+            return r;
+        }
+
+        return -1;
+    }
+};