add

Author: maityamit

010 - BST/011 Largest BST.cpp

@@ -0,0 +1,67 @@
+#include <bits/stdc++.h>
+/**********************************************************
+
+	Following is the Binary Tree Node class structure
+
+	template <typename T>
+	class BinaryTreeNode {
+    	public: 
+    	T data;
+    	BinaryTreeNode<T> *left;
+    	BinaryTreeNode<T> *right;
+
+    	BinaryTreeNode(T data) {
+        	this->data = data;
+        	left = NULL;
+        	right = NULL;
+    	}
+	};
+	
+***********************************************************/
+#include<climits>
+#include<cmath>
+class Pair{
+    
+   public:
+  int minimum;
+  int maximum;
+  bool bst;
+   int height;
+};
+
+Pair BST(BinaryTreeNode<int> *root)
+{
+    if(root==NULL)
+    {
+       Pair obj;
+        obj.minimum =INT_MAX;
+        obj.maximum = INT_MIN;
+        obj.bst = true;
+        obj.height=0;
+    return obj;
+    }
+    
+    Pair left= BST(root->left);
+    Pair right =BST(root->right);
+    
+    int minimum=min(root->data,min(left.minimum,right.minimum));
+    int maximum=max(root->data,max(left.maximum,right.maximum));
+    bool  isBSTfinal=(root->data >left.maximum) && (root->data < right.minimum) && left.bst && right.bst;
+   
+    Pair obj;
+    obj.minimum=minimum;
+    obj.maximum=maximum;
+    obj.bst=isBSTfinal;
+    if(isBSTfinal)
+    {
+        obj.height= 1+max(left.height,right.height);
+    }
+    else   obj.height= max(left.height,right.height);
+    return obj;
+    
+}
+
+int largestBSTSubtree(BinaryTreeNode<int> *root) {
+    // Write your code here
+    return BST(root).height;
+    }

010 - BST/012 Replace with Sum of greater nodes.cpp

@@ -0,0 +1,31 @@
+/**********************************************************
+
+	Following is the Binary Tree Node class structure
+
+	template <typename T>
+	class BinaryTreeNode {
+    	public: 
+    	T data;
+    	BinaryTreeNode<T> *left;
+    	BinaryTreeNode<T> *right;
+
+    	BinaryTreeNode(T data) {
+        	this->data = data;
+        	left = NULL;
+        	right = NULL;
+    	}
+	};
+
+***********************************************************/
+int ans = 0;
+void replaceWithLargerNodesSum(BinaryTreeNode<int> *root) {
+    // Write your code here
+    if(root==NULL){
+        return;
+    }
+    replaceWithLargerNodesSum(root->right);
+    int val = root->data;
+    ans+=val;
+    root->data=ans;
+    replaceWithLargerNodesSum(root->left);
+}

010 - BST/013 Path Sum Root to Leaf.cpp

@@ -0,0 +1,53 @@
+/**********************************************************
+
+	Following is the Binary Tree Node class structure
+
+	template <typename T>
+	class BinaryTreeNode {
+    	public : 
+    	T data;
+    	BinaryTreeNode<T> *left;
+    	BinaryTreeNode<T> *right;
+
+    	BinaryTreeNode(T data) {
+        	this -> data = data;
+        	left = NULL;
+        	right = NULL;
+    	}
+	};
+
+***********************************************************/
+
+#include<vector>
+
+void rootToLeafPathsSumToK(BinaryTreeNode<int> *root, int k,vector<int> path)
+{
+    if(root==NULL)
+        return;
+    
+    path.push_back(root->data);
+    k=k- root->data;
+    
+    if(!root->left && !root->right) // leaf node
+    {
+        if(k==0)
+        {
+            for(int i : path)
+            {
+                cout<< i<<" ";
+            }
+            cout<<endl;
+        }
+        path.pop_back();
+        return;
+    }
+    rootToLeafPathsSumToK(root->left,k,path);    
+    rootToLeafPathsSumToK(root->right,k,path);
+    
+}
+void rootToLeafPathsSumToK(BinaryTreeNode<int> *root, int k) {
+    // Write your code here
+    vector<int> v;
+    rootToLeafPathsSumToK(root,k,v);
+    return;
+}

010 - BST/014 Print nodes at distance k from node.cpp

@@ -0,0 +1,94 @@
+/**********************************************************
+
+        Following is the Binary Tree Node class structure
+
+        template <typename T>
+        class BinaryTreeNode {
+        public :
+        T data;
+        BinaryTreeNode<T> *left;
+        BinaryTreeNode<T> *right;
+
+        BinaryTreeNode(T data) {
+                this -> data = data;
+                left = NULL;
+                right = NULL;
+        }
+        };
+
+***********************************************************/
+
+void printkdistanceNodeDown(BinaryTreeNode<int>*root, int k) 
+{ 
+    // Base Case 
+    if (root == NULL || k < 0)  return; 
+  
+    // If we reach a k distant node, print it 
+    if (k==0) 
+    { 
+        cout << root->data << endl; 
+        return; 
+    } 
+  
+    // Recur for left and right subtrees 
+    printkdistanceNodeDown(root->left, k-1); 
+    printkdistanceNodeDown(root->right, k-1); 
+} 
+// Prints all nodes at distance k from a given target node. 
+// The k distant nodes may be upward or downward.  This function 
+// Returns distance of root from target node, it returns -1 if target 
+// node is not present in tree rooted with root. 
+
+    // Write your code here
+int printkdistanceNode(BinaryTreeNode<int>* root, int target , int k) 
+{ 
+    // Base Case 1: If tree is empty, return -1 
+    if (root == NULL) return -1; 
+  
+    // If target is same as root.  Use the downward function 
+    // to print all nodes at distance k in subtree rooted with 
+    // target or root 
+    if (root->data == target) 
+    { 
+        printkdistanceNodeDown(root, k); 
+        return 0; 
+    } 
+  
+    // Recur for left subtree 
+    int dl = printkdistanceNode(root->left, target, k); 
+  
+    // Check if target node was found in left subtree 
+    if (dl != -1) 
+    { 
+         // If root is at distance k from target, print root 
+         // Note that dl is Distance of root's left child from target 
+         if (dl + 1 == k) 
+            cout << root->data << endl; 
+  
+         // Else go to right subtree and print all k-dl-2 distant nodes 
+         // Note that the right child is 2 edges away from left child 
+         else
+            printkdistanceNodeDown(root->right, k-dl-2); 
+  
+         // Add 1 to the distance and return value for parent calls 
+         return 1 + dl; 
+    } 
+  
+    // MIRROR OF ABOVE CODE FOR RIGHT SUBTREE 
+    // Note that we reach here only when node was not found in left subtree 
+    int dr = printkdistanceNode(root->right, target, k); 
+    if (dr != -1) 
+    { 
+         if (dr + 1 == k) 
+            cout << root->data << endl; 
+         else
+            printkdistanceNodeDown(root->left, k-dr-2); 
+         return 1 + dr; 
+    } 
+  
+    // If target was neither present in left nor in right subtree 
+    return -1; 
+} 
+void nodesAtDistanceK(BinaryTreeNode<int> *root, int node, int k) {
+ int x= printkdistanceNode(root,node,k);
+}

010 - BST/015 Pair sum in a BST.cpp

@@ -0,0 +1,52 @@
+/**********************************************************
+
+	Following is the Binary Tree Node class structure
+
+	template <typename T>
+	class BinaryTreeNode {
+    	public: 
+    	T data;
+    	BinaryTreeNode<T> *left;
+    	BinaryTreeNode<T> *right;
+
+    	BinaryTreeNode(T data) {
+        	this->data = data;
+        	left = NULL;
+        	right = NULL;
+    	}
+	};
+	
+***********************************************************/
+#include <bits/stdc++.h>
+vector<int> arrayPreOrder(BinaryTreeNode<int>* root){
+    vector<int> temp;
+    if(root==NULL){
+        return temp;
+    }
+    vector<int> l = arrayPreOrder(root->left);
+    temp.insert(temp.end(),l.begin(),l.end());
+    temp.push_back(root->data);
+    vector<int> r = arrayPreOrder(root->right);
+    temp.insert(temp.end(),r.begin(),r.end());
+    return temp;
+}
+void printData(vector<int> vt,int sum){
+    int i=0;
+    int j=vt.size()-1;
+    while(i<j){
+        if(vt[i]+vt[j]==sum){
+            cout<<vt[i]<<" "<<vt[j]<<endl;
+            i++;
+            j--;
+        }else if(vt[i]+vt[j] > sum){
+            j--;
+        }else{
+            i++;
+        }
+    }
+}
+void printNodesSumToS(BinaryTreeNode<int> *root, int s) {
+    // Write your code here
+    vector<int> vt = arrayPreOrder(root);
+    printData(vt,s);
+}