Added Tree Problems in Java and CPP

Author: devangi2000

Trees/KthLargestElementInBST.cpp

@@ -0,0 +1,52 @@
+// Given a Binary search tree. Your task is to complete the function which will return the Kth largest element without doing any modification in Binary Search Tree.
+
+
+// Example 1:
+
+// Input:
+//       4
+//     /   \
+//    2     9
+// k = 2 
+// Output: 4
+
+// Example 2:
+
+// Input:
+//        9
+//         \ 
+//           10
+// K = 1
+// Output: 10
+
+// Your Task:
+// You don't need to read input or print anything. Your task is to complete the function kthLargest() which takes the root of the BST and an integer K as inputs and returns the Kth largest element in the given BST.
+
+
+// Expected Time Complexity: O(H + K).
+// Expected Auxiliary Space: O(H)
+
+
+// Constraints:
+// 1 <= N <= 1000
+// 1 <= K <= N
+
+class Solution
+{
+    public:
+    int kthLargest(Node *root, int k)
+    {
+        stack<Node*> st;
+        while(!st.empty() || root){
+            while(root){
+                st.push(root);
+                root = root->right;
+            }
+            root = st.top(); st.pop();
+            if(--k == 0)
+                return root->data;
+            else root = root->left;
+        }
+        return -1;
+    }
+};

Trees/KthLargestElementInBST.java

@@ -0,0 +1,65 @@
+// Given a Binary search tree. Your task is to complete the function which will return the Kth largest element without doing any modification in Binary Search Tree.
+
+
+// Example 1:
+
+// Input:
+//       4
+//     /   \
+//    2     9
+// k = 2 
+// Output: 4
+
+// Example 2:
+
+// Input:
+//        9
+//         \ 
+//           10
+// K = 1
+// Output: 10
+
+// Your Task:
+// You don't need to read input or print anything. Your task is to complete the function kthLargest() which takes the root of the BST and an integer K as inputs and returns the Kth largest element in the given BST.
+
+
+// Expected Time Complexity: O(H + K).
+// Expected Auxiliary Space: O(H)
+
+
+// Constraints:
+// 1 <= N <= 1000
+// 1 <= K <= N
+
+/*
+class Node
+{
+    int data;
+    Node left;
+    Node right;
+    Node(int data)
+    {
+        this.data = data;
+        left=null;
+        right=null;
+    }
+}
+*/
+class Solution
+{
+    // return the Kth largest element in the given BST rooted at 'root'
+    public int kthLargest(Node root,int k)
+    {
+        Stack<Node> st = new Stack<>();
+        while(root != null || !st.isEmpty()){
+            while(root != null){
+                st.push(root);
+                root = root.right;
+            }
+            root = st.pop();
+            if(--k == 0) return root.data;
+            else root = root.left;
+        }
+        return -1;
+    }
+}

Trees/KthSmallestElementInBST.cpp

@@ -0,0 +1,66 @@
+// Given the root of a binary search tree, and an integer k, return the kth smallest value (1-indexed) of all the
+//  values of the nodes in the tree.
+
+// Example 1:
+// Input: root = [3,1,4,null,2], k = 1
+// Output: 1
+// Example 2:
+// Input: root = [5,3,6,2,4,null,null,1], k = 3
+// Output: 3
+
+// Constraints:
+// The number of nodes in the tree is n.
+// 1 <= k <= n <= 104
+// 0 <= Node.val <= 104
+
+// Follow up: If the BST is modified often (i.e., we can do insert and delete operations) and you need to find the 
+// kth smallest frequently, how would you optimize?
+
+// Method 1
+
+/**
+ * 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:
+    vector<int> v;
+    void solve(TreeNode *root, vector<int> &v)
+    {
+        if(root==NULL)return;
+        solve(root->left, v);
+        v.push_back(root->val);
+        solve(root->right, v);
+        return;
+    }
+    int kthSmallest(TreeNode* root, int k) {
+        solve(root, v);
+        return v[k-1];
+    }
+};
+
+// Method 2
+
+class Solution {
+public:
+    int kthSmallest(TreeNode* root, int k) {
+        stack<TreeNode*> st;
+        while(root || !st.empty()){
+            while(root){
+                st.push(root);
+                root = root->left;
+            }
+            root = st.top(); st.pop();
+            if(--k == 0) return root->val;
+            else root = root->right;
+        }
+        return -1;
+    }
+};

Trees/KthSmallestElementInBST.java

@@ -0,0 +1,48 @@
+// Given the root of a binary search tree, and an integer k, return the kth smallest value (1-indexed) of all the
+//  values of the nodes in the tree.
+
+// Example 1:
+// Input: root = [3,1,4,null,2], k = 1
+// Output: 1
+// Example 2:
+// Input: root = [5,3,6,2,4,null,null,1], k = 3
+// Output: 3
+
+// Constraints:
+// The number of nodes in the tree is n.
+// 1 <= k <= n <= 104
+// 0 <= Node.val <= 104
+
+// Follow up: If the BST is modified often (i.e., we can do insert and delete operations) and you need to find the 
+// kth smallest frequently, how would you optimize?
+
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public int kthSmallest(TreeNode root, int k) {
+        Stack<TreeNode> st = new Stack<>();
+        while(root != null || !st.isEmpty()){
+            while(root != null){
+                st.push(root);
+                root = root.left;
+            }
+            root = st.pop();
+            if(--k == 0) return root.val;
+            else root = root.right;
+        }
+        return -1;
+    }
+}

Trees/LargestBSTInABinaryTree.cpp

@@ -0,0 +1,78 @@
+// Given a binary tree. Find the size of its largest subtree that is a Binary Search Tree.
+// Note: Here Size is equal to the number of nodes in the subtree.
+
+// Example 1:
+
+// Input:
+//         1
+//       /   \
+//      4     4
+//    /   \
+//   6     8
+// Output: 1
+// Explanation: There's no sub-tree with size
+// greater than 1 which forms a BST. All the
+// leaf Nodes are the BSTs with size equal
+// to 1.
+// Example 2:
+
+// Input: 6 6 3 N 2 9 3 N 8 8 2
+//             6
+//         /       \
+//        6         3
+//         \      /   \
+//          2    9     3
+//           \  /  \
+//           8 8    2 
+// Output: 2
+// Explanation: The following sub-tree is a
+// BST of size 2: 
+//        2
+//     /    \ 
+//    N      8
+// Your Task:
+// You don't need to read input or print anything. Your task is to complete the function largestBst() that takes the root node of the Binary Tree as its input and returns the size of the largest subtree which is also the BST. If the complete Binary Tree is a BST, return the size of the complete Binary Tree. 
+
+// Expected Time Complexity: O(N).
+// Expected Auxiliary Space: O(Height of the BST).
+
+// Constraints:
+// 1 ≤ Number of nodes ≤ 105
+// 1 ≤ Data of a node ≤ 106
+/*
+struct Node {
+    int data;
+    Node *left;
+    Node *right;
+
+    Node(int val) {
+        data = val;
+        left = right = NULL;
+    }
+};*/
+
+class Solution{
+    public:
+    vector<int> solve(Node *root){
+        if(!root) return {1, 0, INT_MAX, INT_MIN};
+        if(!root->left and !root->right) return {1, 1, root->data, root->data};
+        
+        vector<int> l = solve(root->left);
+        vector<int> r = solve(root->right);
+        if(l[0] and r[0]){
+            if(root->data > l[3] and root->data < r[2]){
+                int x = l[2], y = r[3];
+                if(x == INT_MAX) x = root->data;
+                if(y == INT_MIN) y = root->data;
+                return {1, l[1] + r[1] + 1, x, y};
+            }
+        }
+        return {0, max(l[1], r[1]), 0, 0};
+    }
+    
+    int largestBst(Node *root)
+    {
+    	vector<int> ans = solve(root);
+    	return ans[1];
+    }
+};

Trees/LargestBSTInABinaryTree.java

@@ -0,0 +1,43 @@
+// Given a binary tree. Find the size of its largest subtree that is a Binary Search Tree.
+// Note: Here Size is equal to the number of nodes in the subtree.
+
+// Example 1:
+
+// Input:
+//         1
+//       /   \
+//      4     4
+//    /   \
+//   6     8
+// Output: 1
+// Explanation: There's no sub-tree with size
+// greater than 1 which forms a BST. All the
+// leaf Nodes are the BSTs with size equal
+// to 1.
+// Example 2:
+
+// Input: 6 6 3 N 2 9 3 N 8 8 2
+//             6
+//         /       \
+//        6         3
+//         \      /   \
+//          2    9     3
+//           \  /  \
+//           8 8    2 
+// Output: 2
+// Explanation: The following sub-tree is a
+// BST of size 2: 
+//        2
+//     /    \ 
+//    N      8
+// Your Task:
+// You don't need to read input or print anything. Your task is to complete the function largestBst() that takes the root node of the Binary Tree as its input and returns the size of the largest subtree which is also the BST. If the complete Binary Tree is a BST, return the size of the complete Binary Tree. 
+
+// Expected Time Complexity: O(N).
+// Expected Auxiliary Space: O(Height of the BST).
+
+// Constraints:
+// 1 ≤ Number of nodes ≤ 105
+// 1 ≤ Data of a node ≤ 106
+
+// To do