GFG and Leetcode

Author: harshit2608

GeeksForGeeks/Medium/Bottom View of Binary Tree .cpp

@@ -0,0 +1,30 @@
+vector<int> bottomView(Node *root)
+{
+    vector<int> ans;
+    map<int, vector<int>> m;
+    queue<pair<Node *, int>> q;
+    int dist = 0;
+    q.push(make_pair(root, 0));
+    while (!q.empty())
+    {
+        pair<Node *, int> p = q.front();
+        Node *curr = p.first;
+        dist = p.second;
+        m[dist].push_back(curr->data);
+        q.pop();
+        if (curr->left)
+        {
+            q.push(make_pair(curr->left, dist - 1));
+        }
+        if (curr->right)
+        {
+            q.push(make_pair(curr->right, dist + 1));
+        }
+    }
+    map<int, vector<int>>::iterator itr;
+    for (itr = m.begin(); itr != m.end(); itr++)
+    {
+        ans.push_back(itr->second.back());
+    }
+    return ans;
+}

GeeksForGeeks/Medium/Complete Binary Tree.cpp

@@ -0,0 +1,28 @@
+bool isCompleteBT(Node *root)
+{
+    bool bt = false;
+    queue<Node *> q;
+    q.push(root);
+    while (!q.empty())
+    {
+        Node *curr = q.front();
+        q.pop();
+        if (curr == nullptr)
+        {
+            bt = true;
+        }
+        else
+        {
+            if (bt == true)
+            {
+                return false;
+            }
+            else
+            {
+                q.push(curr->left);
+                q.push(curr->right);
+            }
+        }
+    }
+    return true;
+}

GeeksForGeeks/Medium/Preorder Traversal and BST.cpp

@@ -0,0 +1,32 @@
+
+class Solution
+{
+public:
+    int canRepresentBST(int arr[], int N)
+    {
+        int mini = INT_MIN;
+        int maxi1 = INT_MIN;
+        int maxi2 = arr[0];
+        for (int i = 1; i < N; ++i)
+        {
+            if (arr[i] < mini)
+            {
+                return 0;
+            }
+            if (arr[i] < maxi1)
+            {
+                return 0;
+            }
+            else if (arr[i] > arr[i - 1]) //right side
+            {
+                mini = arr[i - 1];
+                if (arr[i] > maxi2)
+                {
+                    maxi1 = max(maxi2, maxi1);
+                    maxi2 = arr[i];
+                }
+            }
+        }
+        return 1;
+    }
+};

Leet Code/C++/1038. Binary Search Tree to Greater Sum Tree.cpp

@@ -0,0 +1,36 @@
+/**
+ * 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 sum = 0;
+    void revin(TreeNode *root)
+    {
+        if (root == nullptr)
+        {
+            return;
+        }
+        else
+        {
+            revin(root->right);
+            root->val = root->val + sum;
+            sum = root->val;
+            revin(root->left);
+        }
+    }
+
+    TreeNode *bstToGst(TreeNode *root)
+    {
+        revin(root);
+        return root;
+    }
+};

Leet Code/C++/104. Maximum Depth of Binary Tree.cpp

@@ -0,0 +1,15 @@
+class Solution
+{
+public:
+    int maxDepth(TreeNode *root)
+    {
+        if (root == nullptr)
+        {
+            return 0;
+        }
+        // int l = 1+ maxDepth(root->left);
+        // int r = 1 + maxDepth(root->right);
+
+        return max(maxDepth(root->left), maxDepth(root->right)) + 1;
+    }
+};

Leet Code/C++/1302. Deepest Leaves Sum.cpp

@@ -0,0 +1,46 @@
+/**
+ * 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 deepestLeavesSum(TreeNode *root)
+    {
+        int sum = 0, ans = 0;
+        queue<TreeNode *> q;
+        if (root == nullptr)
+        {
+            return ans;
+        }
+        q.push(root);
+        while (!q.empty())
+        {
+            int sz = q.size();
+            sum = 0;
+            while (sz--)
+            {
+                TreeNode *curr = q.front();
+                q.pop();
+                sum += curr->val;
+                if (curr->left)
+                {
+                    q.push(curr->left);
+                }
+                if (curr->right)
+                {
+                    q.push(curr->right);
+                }
+            }
+            ans = sum;
+        }
+        return ans;
+    }
+};

Leet Code/C++/1379. Find a Corresponding Node of a Binary Tree in a Clone of That Tree.cpp

@@ -0,0 +1,30 @@
+/**
+ * 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:
+    TreeNode *ans;
+    TreeNode *getTargetCopy(TreeNode *original, TreeNode *cloned, TreeNode *target)
+    {
+        if (target == nullptr || cloned == nullptr)
+        {
+            return nullptr;
+        }
+
+        if (cloned->val == target->val)
+        {
+            ans = cloned;
+        }
+        getTargetCopy(original, cloned->left, target);
+        getTargetCopy(original, cloned->right, target);
+        return ans;
+    }
+};

Leet Code/C++/938. Range Sum of BST.cpp

@@ -0,0 +1,65 @@
+/**
+ * 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) {}
+ * };
+ */
+// #pragma GCC optimize("Ofast")
+// #pragma GCC target("avx,avx2,fma")
+// static auto _ = [] ()
+// {ios_base::sync_with_stdio(false);cin.tie(nullptr);cout.tie(nullptr);return 0;}();
+class Solution
+{
+public:
+    int rangeSumBST(TreeNode *root, int low, int high)
+    {
+        //     int ans =0;
+        //     queue<TreeNode*> q;
+        //     if(root == nullptr)
+        //     {
+        //         return ans;
+        //     }
+        //     q.push(root);
+        //     while(!q.empty())
+        //     {
+        //         int sz = q.size();
+        //         while(sz--)
+        //         {
+        //             TreeNode* curr = q.front();
+        //             if(curr->val >=low and curr->val <=high)
+        //             {
+        //                 ans += curr->val;
+        //             }
+        //             q.pop();
+        //             if(curr->left)
+        //             {
+        //                 q.push(curr->left);
+        //             }
+        //             if(curr->right)
+        //             {
+        //                 q.push(curr->right);
+        //             }
+        //         }
+        //     }
+        //     return ans;
+        // }
+        int ans = 0;
+        if (root == nullptr)
+        {
+            return ans;
+        }
+        if (root->val <= high && root->val >= low)
+        {
+            ans += root->val;
+        }
+        ans += rangeSumBST(root->left, low, high);
+        ans += rangeSumBST(root->right, low, high);
+        root->left = root->right = nullptr;
+        return ans;
+    }
+};