___________________________________________________________________________________

_Q.)61 pre order traversal

https://practice.geeksforgeeks.org/problems/preorder-traversal/1?
page=1&category[]=Tree&sortBy=submissions

void solve(Node* root,vector <int> &v){

// base case
if(root==NULL){
return ;
}
v.push_back(root->data);
solve(root->left,v);
solve(root->right,v);
}

vector <int> preorder(Node* root)

{
vector<int> v;
solve(root, v);

return v;
}

_____________________________________________________________________Q.62) Inorder
traversal

https://practice.geeksforgeeks.org/problems/inorder-traversal/1?
page=1&category[]=Tree&sortBy=submissions

void solve(Node* root, vector<int> &v){

//base case
if(root == NULL){
return;
}
solve(root->left,v);
v.push_back(root->data);
solve(root->right,v);
}

vector<int> inOrder(Node* root) {

vector<int> v;
solve(root,v);

return v;
}
_________________________________________________________________Q.63) post order
traversal

https://practice.geeksforgeeks.org/problems/postorder-traversal/1?
page=2&category[]=Tree&sortBy=submissions

void solve(Node* root, vector<int> &v){

//base case
if(root == NULL){
return;
}
solve(root->left,v);
solve(root->right,v);
v.push_back(root->data);
}

vector <int> postOrder(Node* root)

{
vector<int> v;
solve(root, v);

return v;
}

____________________________________________________________________ All three

traversal combine

https://www.codingninjas.com/codestudio/problems/tree-traversal_981269?
source=youtube&amp;campaign=Striver_Tree_Videos&amp;utm_source=youtube&amp;utm_medi
um=affiliate&amp;utm_campaign=Striver_Tree_Videos&leftPanelTab=1

void preorder(BinaryTreeNode<int> *root, vector<int> &v2){

//base case
if(root == NULL){
return;
}
v2.push_back(root->data);
preorder(root->left,v2);
preorder(root->right,v2);
}

void inorder(BinaryTreeNode<int> *root, vector<int> &v1){

//base case
 if(root == NULL){
return;
}
inorder(root->left,v1);
v1.push_back(root->data);
inorder(root->right,v1);
}

void postorder(BinaryTreeNode<int> *root, vector<int> &v3){

//base case
if(root == NULL){
return;
}
postorder(root->left,v3);
postorder(root->right,v3);
v3.push_back(root->data);
}

vector<vector<int>> getTreeTraversal(BinaryTreeNode<int> *root){

vector<vector<int>> v;
vector<int> v1;
vector<int> v2;
vector<int> v3;

inorder(root,v1);
preorder(root,v2);
postorder(root,v3);

v.push_back(v1);
v.push_back(v2);
v.push_back(v3);

return v;

______________________________________________________________________________Q.64)
Height of Binary Tree

https://practice.geeksforgeeks.org/problems/height-of-binary-tree/1

int height(struct Node* node){

queue<Node*> q;
int count = 0;
q.push(node);
q.push(NULL);
while(!q.empty()){
Node* temp = q.front();
q.pop();
if(temp == NULL){
count++;
if(!q.empty()){
q.push(NULL);
 }
}
else{
if(temp->left != NULL){
q.push(temp->left);
}
if(temp->right != NULL){
q.push(temp->right);
}
}
}
return count;
}

____________________________________________________________________________Q.65)
Diameter of a Binary Tree

https://practice.geeksforgeeks.org/problems/diameter-of-binary-tree/1

pair<int, int> diameterFast(Node* root){

pair<int,int> p;
//base case
if(root == NULL){
return p;
}
Node* temp = root;
pair<int, int> left = diameterFast(temp->left);
pair<int, int> right = diameterFast(temp->right);

int opt1 = left.first;

int opt2 = right.first;
int opt3 = left.second + right.second + 1;

pair<int, int> ans;

ans.first = max(opt1, max(opt2,opt3));
ans.second = max(left.second,right.second)+1;

return ans;
}

int diameter(Node* root) {

return diameterFast(root).first;
}
________________________________________________________________________Q.66) Check
for Balanced Tree

https://practice.geeksforgeeks.org/problems/check-for-balanced-tree/1

____________________Method 1 T-O(n^2)

int height(Node* root){

//base case
if(root==NULL){
return 0;
}
Node* temp = root;
int left = height(temp->left);
int right = height(temp->right);

int ans = max(left,right)+1;

return ans;
}

bool isBalanced(Node *root)

{

stack<Node*> s;
s.push(root);
while(!s.empty()){
Node* temp = s.top();
s.pop();
int ansL = height(temp->left);
int ansR = height(temp->right);

if(abs(ansL-ansR)>1){
return false;
}
if(temp->right){
s.push(temp->right);
}
if(temp->left){
s.push(temp->left);
}
}
return true;

____________Method 2

pair<bool, int> isBalancedFast(Node* root){

pair<bool, int> p = make_pair(true , 0);
if(root == NULL){
return p;
}

pair<bool, int> left = isBalancedFast(root->left);

pair<bool, int> right = isBalancedFast(root->right);

bool ansL = left.first;

bool ansR = right.first;
 bool diff = abs(left.second - right.second) <= 1;

pair<bool, int> ans;

ans.second = max(left.second , right.second) + 1;
if(ansL && ansR && diff){
ans.first = true;
}
else{
ans.first = false;
}

return ans;
}

bool isBalanced(Node *root)

{
return isBalancedFast(root).first;
}

________________________________________________________________________________Q.6
7) Determine if Two Trees are Identical

https://practice.geeksforgeeks.org/problems/determine-if-two-trees-are-identical/1

bool isIdentical(Node *r1, Node *r2)

{
//base case
if(r1 == NULL && r2 == NULL){
return true;
}
if(r1 == NULL && r2 != NULL){
return false;
}
if(r1 != NULL && r2 == NULL){
return false;
}

bool left = isIdentical(r1->left,r2->left);

bool right = isIdentical(r1->right,r2->right);
bool data;
if(r1->data == r2->data){
data = true;
}

if(left && right && data){

return true;
}
else{
return false;
}

}
_____________________________________________________________________________Q.68)
Sum tree

https://practice.geeksforgeeks.org/problems/sum-tree/1

pair<bool,int> isSumTreeFast(Node* root){

//base case
if(root == NULL){
pair<bool,int> p = make_pair(true , 0);
return p;
}
if(root->left == NULL && root->right == NULL){
pair<bool,int> p = make_pair(true , root->data);
return p;
}

pair<bool,int> left = isSumTreeFast(root->left);

pair<bool,int> right = isSumTreeFast(root->right);

bool ansL = left.first;

bool ansR = right.first;
bool sum = (left.second + right.second) == root->data;

pair<bool,int> ans;

if(ansL && ansR && sum){

ans.first = true;
ans.second = 2*root->data;
}
else{
ans.second = false;
}
return ans;
}

bool isSumTree(Node* root)

{
return isSumTreeFast(root).first;
}

_______________________________________________________________________________Q.69
) ZigZag Tree Traversal
https://practice.geeksforgeeks.org/problems/zigzag-tree-traversal/1

vector <int> zigZagTraversal(Node* root)

{
vector<int> result;
if(root == NULL){
return result;
}
queue<Node*> q;
q.push(root);
bool LeftToRight = true;

while(!q.empty()){
int size = q.size();
vector<int> ans(size);

//level process
for(int i=0; i<size; i++){
Node* temp = q.front();
q.pop();

//normal insert or reverse insert

int index = LeftToRight ? i : size-1-i;
ans[index] = temp->data;

if(temp->left){
q.push(temp->left);
}
if(temp->right){
q.push(temp->right);
}
}
// direction change karni h
LeftToRight = !LeftToRight;

for(int i=0; i<ans.size(); i++){

result.push_back(ans[i]);
}
}
return result;

________________________________________________________________________________Q.7
0) Boundary Traversal of binary tree

Boundary Traversal of binary tree

void leftTraverse(Node* root, vector<int> &ans){

//base case
 if((root == NULL) || (root->left == NULL && root->right == NULL)){
return;
}
ans.push_back(root->data);
if(root->left){
leftTraverse(root->left,ans);
}
else{
leftTraverse(root->right,ans);
}
}

void leafTraverse(Node* root, vector<int> &ans){

//base case
if(root == NULL){
return;
}
if(root->left == NULL && root->right == NULL){
ans.push_back(root->data);
return;
}
leafTraverse(root->left,ans);
leafTraverse(root->right,ans);
}

void rightTraverse(Node* root, vector<int> &ans){

if((root == NULL) || (root->left == NULL && root->right == NULL)){
return;
}
if(root->right){
rightTraverse(root->right,ans);
}
else{
rightTraverse(root->left,ans);
}

//wapis aagya
ans.push_back(root->data);
}

vector <int> boundary(Node *root)

{
vector<int> ans;
if(root == NULL){
return ans;
}
ans.push_back(root->data);
//left
leftTraverse(root->left , ans);

//leaf
leafTraverse(root->left, ans);
leafTraverse(root->right, ans);

//right
rightTraverse(root->right, ans);

return ans;
}
_________________________________________________________________________________Q.
71) Vertical Traversal of Binary Tree

https://practice.geeksforgeeks.org/problems/print-a-binary-tree-in-vertical-order/1

vector<int> verticalOrder(Node *root)

{
map<int , map<int, vector<int> > > nodes;
queue<pair<Node* , pair<int, int> > > q;
vector<int> ans;

if(root == NULL){
return ans;
}

q.push(make_pair(root,make_pair(0,0)));

while(!q.empty()){
pair<Node* , pair<int, int> > temp = q.front();
q.pop();
Node* frontNode = temp.first;
int hd = temp.second.first;
int lvl = temp.second.second;

nodes[hd][lvl].push_back(frontNode->data);

if(frontNode->left){
q.push(make_pair(frontNode->left, make_pair(hd-1 , lvl+1)));
}
if(frontNode->right){
q.push(make_pair(frontNode->right, make_pair(hd+1 , lvl+1)));
}

}
for(auto i : nodes){
for(auto j : i.second){
for(auto k : j.second){
ans.push_back(k);
}
}
}
return ans;
}
______________________________________________________________________Q.72) Top
View of Binary Tree

https://practice.geeksforgeeks.org/problems/top-view-of-binary-tree/1

vector<int> topView(Node *root)

{
map<int , int> topNode;
queue<pair<Node*,int> > q;
vector<int> ans;

//base case
if(root == NULL){
return ans;
}

q.push(make_pair(root,0));

while(!q.empty()){
pair<Node*,int> temp = q.front();
q.pop();
Node* frontNode = temp.first;
int hd = temp.second;

if(topNode.find(hd) == topNode.end()){
topNode[hd] = frontNode->data;
}

if(frontNode->left){
q.push(make_pair(frontNode->left,hd-1));
}
if(frontNode->right){
q.push(make_pair(frontNode->right,hd+1));
}

}
for(auto i : topNode){
ans.push_back(i.second);
}
return ans;

______________________________________________________________________________Q.73)
Bottom View of Binary Tree

https://practice.geeksforgeeks.org/problems/bottom-view-of-binary-tree/1
vector <int> bottomView(Node *root) {
map<int , int> topNode;
queue<pair<Node*, int> > q;
vector<int> ans;

//base case
if(root == NULL){
return ans;
}

q.push(make_pair(root, 0));

while(!q.empty()){
pair<Node*, int> temp = q.front();
q.pop();
Node* frontNode = temp.first;
int hd = temp.second;

topNode[hd] = frontNode->data;

if(frontNode->left){
q.push(make_pair(frontNode->left,hd-1));
}
if(frontNode->right){
q.push(make_pair(frontNode->right,hd+1));
}

}
for(auto i : topNode){
ans.push_back(i.second);
}
return ans;

__________________________________________________________________________Q.74)
Left View of Binary Tree

https://practice.geeksforgeeks.org/problems/left-view-of-binary-tree/1

void solve(Node* root, vector<int> &ans, int level){

// base case
if(root == NULL){
return;
}

// we entered into next level

if(level == ans.size()){
ans.push_back(root->data);
}
 solve(root->left, ans, level+1);
solve(root->right, ans, level+1);

}
vector<int> leftView(Node *root)
{
vector<int> ans;
solve(root, ans ,0);
return ans;
}

_____________________________________________________________________Q.75)
RightView of Binary Tree

https://practice.geeksforgeeks.org/problems/right-view-of-binary-tree/1

void solve(Node* root, vector<int> &ans, int level){

// base case
if(root == NULL){
return;
}

// we entered into next level

if(level == ans.size()){
ans.push_back(root->data);
}

solve(root->right, ans, level+1);

solve(root->left, ans, level+1);

vector<int> rightView(Node *root)

{
vector<int> ans;
solve(root, ans ,0);
return ans;
}

_______________________________________________________________________Q.77) Sum of
the Longest Bloodline of a Tree (Sum of nodes on the longest path from root to leaf
node)

https://practice.geeksforgeeks.org/problems/sum-of-the-longest-bloodline-of-a-
tree/1

void solve(Node* root, int len, int &maxLen, int sum, int &maxSum){
// base case
if(root == NULL){
if(len > maxLen){
maxLen = len;
maxSum = sum;
}
else if(len == maxLen){
maxSum = max(sum,maxSum);
}
return;
}
sum = sum + root->data;

solve(root->left, len+1, maxLen, sum, maxSum);

solve(root->right, len+1, maxLen, sum, maxSum);
}

int sumOfLongRootToLeafPath(Node *root)

{
int len = 0;
int maxLen = 0;
int sum = 0;
int maxSum = INT_MIN;

solve(root, len, maxLen, sum, maxSum);

return maxSum;
}

_____________________________________________________________________________Q. 78)
Lowest Common Ancestor in a Binary Tree

https://practice.geeksforgeeks.org/problems/lowest-common-ancestor-in-a-binary-
tree/1

Node* lca(Node* root ,int n1 ,int n2 )

{
// base case
if(root == NULL){
return NULL;
}
if(root->data == n1 || root->data == n2){
return root;
}
 Node* leftAns = lca(root->left, n1, n2);
Node* rightAns = lca(root->right, n1, n2);

if(leftAns != NULL && rightAns != NULL){

return root;
}
else if(leftAns != NULL && rightAns == NULL){
return leftAns;
}
else if(rightAns != NULL && leftAns == NULL){
return rightAns;
}
else{
return NULL;
}

___________________________________________________________________Q.80) Kth
Ancestor in a Tree

https://practice.geeksforgeeks.org/problems/kth-ancestor-in-a-tree/1

_________________________method 2

Node* solve(Node* root, int &k , int node){

//base case
if(root == NULL){
return NULL;
}
if(root->data == node){
return root;
}

Node* leftAns = solve(root->left, k, node);

Node* rightAns = solve(root->right, k, node);

if(leftAns != NULL && rightAns == NULL){

k--;
if(k<=0){
//ans lock
k = INT_MAX;
return root;
}
return leftAns;
}
if(rightAns != NULL && leftAns == NULL){
k--;
if(k<=0){
 //ans lock
k = INT_MAX;
return root;
}
return rightAns;
}
return NULL;

int kthAncestor(Node *root, int k, int node)

{
Node* ans = solve(root, k, node);
if(ans == NULL || ans->data == node){
return -1;
}
else{
return ans->data;
}
}

____________________________________________________________________________Q.81)
Maximum sum of Non-adjacent nodes

https://practice.geeksforgeeks.org/problems/maximum-sum-of-non-adjacent-nodes/1

pair<int, int> solve(Node* root){

// base case
if(root == NULL){
pair<int, int> p = make_pair(0, 0);
return p;
}

pair<int,int> leftAns = solve(root->left);

pair<int,int> rightAns = solve(root->right);

pair<int, int> result;

result.first = root->data + leftAns.second + rightAns.second;
result.second = max(leftAns.first, leftAns.second) + max(rightAns. first,
rightAns.second);

return result;

int getMaxSum(Node *root)

{
pair<int, int> ans;
//first int = maxSum by including nodes at current level
//second int = maxSum by excluding nodes at current level

ans = solve(root);
 return max(ans.first, ans.second);
}

______________________________________________________________________Q.82)
Construct Tree from Inorder & Preorder (partial correct)

https://practice.geeksforgeeks.org/problems/construct-tree-1/1

void createMapping(int in[], map<int, int> &nodeToInsert, int n){

for(int i=0; i<n; i++){
nodeToInsert[in[i]] = i;
}
}

Node* solve(int in[],int pre[], int n, int &index, int inStart, int inEnd,
map<int, int> &nodeToInsert){
// base case
if(index >= n || inStart > inEnd){
return NULL;
}

int element = pre[index++];

Node* root = new Node(element);
int position = nodeToInsert[element];

root->left = solve(in, pre, n, index, inStart, position-1, nodeToInsert);

root->right = solve(in, pre, n, index, position+1, inEnd, nodeToInsert);

return root;

Node* buildTree(int in[],int pre[], int n)

{
int index = 0;
int inStart = 0;
int inEnd = n-1;

map<int, int> nodeToInsert;

createMapping(in, nodeToInsert, n);

Node* ans = solve(in, pre, n, index, inStart, inEnd, nodeToInsert);

return ans;
}
________________________________________________________________________________Q.8
3) Tree from Postorder and Inorder

https://practice.geeksforgeeks.org/problems/tree-from-postorder-and-inorder/1

void createMapping(int in[], map<int, int> &nodeToInsert, int n){

for(int i=0; i<n; i++){
nodeToInsert[in[i]] = i;
}
}

Node* solve(int in[],int post[], int n, int &index, int inStart, int inEnd,
map<int, int> &nodeToInsert){
// base case
if(index < 0 || inStart > inEnd){
return NULL;
}

//create a root note for element

int element = post[index--];
Node* root = new Node(element);

//fint element's index in inorder

int position = nodeToInsert[element];

//recursive call(in case of postorder and inorder , we first built the

right subtree)
root->right = solve(in, post, n, index, position+1, inEnd, nodeToInsert);
root->left = solve(in, post, n, index, inStart, position-1, nodeToInsert);

return root;

Node *buildTree(int in[], int post[], int n) {

int index = n-1;
int inStart = 0;
int inEnd = n-1;

map<int, int> nodeToInsert;

createMapping(in, nodeToInsert, n);

Node* ans = solve(in, post, n, index, inStart, inEnd, nodeToInsert);

return ans;
}
___________________________________________________________________________________
Q.84) Burning Tree

https://practice.geeksforgeeks.org/problems/burning-tree/1

Node* createParentNode(Node* root, int target, map<Node*, Node*> &nodeToParent)

{
Node* res = NULL;

queue<Node*> q;
q.push(root);

nodeToParent[root] = NULL;

while(!q.empty()){
Node* front = q.front();
q.pop();

if(front->data == target){
res = front;
}
if(front->left){
nodeToParent[front->left] = front;
q.push(front->left);
}
if(front->right){
nodeToParent[front->right] = front;
q.push(front->right);
}
}
return res;

int burnTree(Node* root, map<Node*, Node*> &nodeToParent){

map<Node*, bool> visited;
queue<Node*> q;

q.push(root);
visited[root] = 1;

int ans = 0;

while(!q.empty()){
bool flag = 0;
int size = q.size();
for(int i=0; i<size; i++){
Node* front = q.front();
q.pop();

if(front->left && !visited[front->left]){

flag = 1;
q.push(front->left);
visited[front->left] = 1;
}
 if(front->right && !visited[front->right]){
flag = 1;
q.push(front->right);
visited[front->right] = 1;
}

if(nodeToParent[front] && !visited[nodeToParent[front]]){

flag = 1;
q.push(nodeToParent[front]);
visited[nodeToParent[front]] = 1;
}
}

if(flag == 1){
ans++;
}

}
return ans;
}

int minTime(Node* root, int target)

{
map<Node*, Node*> nodeToParent;
Node* targetNode = createParentNode(root, target, nodeToParent);

int ans = burnTree(targetNode, nodeToParent);

return ans;

_____________________________________________________________________________Q.85)
Flatten binary tree to linked list

https://practice.geeksforgeeks.org/problems/flatten-binary-tree-to-linked-list/1

Node* current = root;

Node* pre;
while(current != NULL){
if(current->left){
pre = current->left;
while(pre->right){
pre = pre->right;
}
pre->right = current->right;
current->right = current->left;
current->left = NULL;
}
current = current->right;
}
_________________________________________________________________________Q.86)Searc
h In BST

https://www.codingninjas.com/codestudio/problems/search-in-bst_1402878?
leftPanelTab=0

__________________________recursion

if(root == NULL){
return false;
}
if(root->data == x){
return true;
}

if(x > root->data){

searchInBST(root->right, x);
}
else{
searchInBST(root->left, x);
}

____________________________iterative

BinaryTreeNode<int> *temp = root;

while(temp != NULL){
if(temp->data == x){
return true;
}
if(x > temp->data){
temp = temp->right;
}
else{
temp = temp->left;
}
}
return false;

______________________________________________________________________________Q.
87) Partial BST/ Is BST

https://www.codingninjas.com/codestudio/problems/validate-bst_799483?leftPanelTab=0

bool isBST(BinaryTreeNode<int> *root, int min, int max){

if(root == NULL){
return true;
}
 if(root->data >= min && root->data <= max){
bool left = isBST(root->left, min, root->data);
bool right = isBST(root->right, root->data, max);
return left & right;
}
else{
return false;
}
}

bool validateBST(BinaryTreeNode<int> *root) {

return isBST(root, INT_MIN, INT_MAX);
}

__________________________________________________________________Q.88)Find K-th
smallest Element in BST

https://www.codingninjas.com/codestudio/problems/find-k-th-smallest-element-in-
bst_1069333?leftPanelTab=0

void solve(BinaryTreeNode<int>* root, vector<int> &v){

if(root == NULL){
return;
}

solve(root->left, v);
v.push_back(root->data);
solve(root->right,v);

int kthSmallest(BinaryTreeNode<int>* root, int k) {

vector<int> v;
solve(root, v, k);
if(k>v.size()){
return -1;
}
else{
return v[k-1];
}
}

_____________________________recursion

void solve(BinaryTreeNode<int>* root, int k, int& ans, int& count){

if(root == NULL){
return;
 }
solve(root->left, k, ans, count);
count++;
if(count == k){
ans = root->data;
return;
}
else{
solve(root->right, k, ans, count);
}
}

int kthSmallest(BinaryTreeNode<int>* root, int k) {

int ans = -1;
int count = 0;
solve(root, k, ans, count);
return ans;
}

_______________________________________________________________________________Q.89
) Predecessor And Successor In BST

https://www.codingninjas.com/codestudio/problems/_893049?topList=love-babbar-dsa-
sheet-problems&leftPanelTab=0

int pred = -1;

int succ = -1;

BinaryTreeNode<int>* temp = root;

while(temp->data != key){
if (key > temp->data) {
pred = temp->data;
temp = temp->right;
}
if (key < temp->data){
succ = temp->data;
temp = temp->left;
}
}
BinaryTreeNode<int>* leftTree = temp->left;
while(leftTree != NULL){
pred = leftTree->data;
leftTree = leftTree->right;
}
BinaryTreeNode<int>* rightTree = temp->right;
while(rightTree != NULL){
succ = rightTree->data;
rightTree = rightTree->left;
}

pair<int, int> p;
 p.first = pred;
p.second = succ;

return p;

______________________________________________________________________________Q.90)
LCA of Two Nodes In A BST

________________________recursion

if(root == NULL){
return NULL;
}
if(P->data > root->data && Q->data > root->data){
return LCAinaBST(root->right, P, Q);
}
else if(P->data < root->data && Q->data < root->data){
return LCAinaBST(root->left, P, Q);
}
else{
return root;
}

_________________iterative

if(root == NULL){
return NULL;
}

while(root != NULL){
if(P->data > root->data && Q->data > root->data){
root = root->right;
}
else if (P->data < root->data && Q->data < root->data) {
root = root->left;
}
else{
return root;
}
}
___________________________________________________________________________________
Q.91) Two Sum IV - Input is a BST

https://www.codingninjas.com/codestudio/problems/two-sum-in-a-bst_1062631?
leftPanelTab=0

void inorder(BinaryTreeNode<int>* root, vector<int> &v){

// base case
if(root == NULL){
return;
}

inorder(root->left, v);
v.push_back(root->data);
inorder(root->right, v);

bool twoSumInBST(BinaryTreeNode<int>* root, int target) {

vector<int> v;
inorder(root, v);

int i = 0;
int j = v.size()-1;

while(i<j){
int sum = v[i] + v[j];
if(sum == target){
return true;
}
else if(sum > target){
j--;
}
else{
i++;
}
}
return false;
}

___________________________________________________________________________________
__Q.92) Flatten BST To A Sorted List

https://www.codingninjas.com/codestudio/problems/flatten-bst-to-a-sorted-
list_1169459?leftPanelTab=0
______________________________partial

void inorder(TreeNode<int>* root, vector<TreeNode<int>* > &v){

if(root == NULL){
return;
}
inorder(root->left, v);
v.push_back(root);
inorder(root->right, v);
}

TreeNode<int>* flatten(TreeNode<int>* root)

{
vector<TreeNode<int>* > v;
inorder(root, v);

for(int i=0; i<v.size()-1; i++){

v[i]->left = NULL;
v[i]->right = v[i+1];
}
v[v.size()-1]->right = NULL;
v[v.size()-1]->left = NULL;

for(int i=0; i<v.size(); i++){

return v[i];
}
}

__________________________________________correct

void inorder(TreeNode<int>* root, vector<int> &v){

if(root == NULL){
return;
}
inorder(root->left, v);
v.push_back(root->data);
inorder(root->right, v);
}

TreeNode<int>* flatten(TreeNode<int>* root)

{
vector<int> v;
inorder(root, v);

TreeNode<int>* startRoot = new TreeNode<int>(v[0]);

TreeNode<int>* curr = startRoot;

for(int i=1; i<v.size(); i++){

TreeNode<int>* temp = new TreeNode<int>(v[i]);
curr->right = temp;
curr->left = NULL;
curr = temp;
}
curr->right = NULL;
 curr->left = NULL;

return startRoot;
}

_______________________________________________________________________Q.93) Normal
BST To Balanced BST

https://www.codingninjas.com/codestudio/problems/normal-bst-to-balanced-bst_920472?
leftPanelTab=0

void inorder(TreeNode<int>* root, vector<int> &v){

if(root == NULL){
return;
}
inorder(root->left, v);
v.push_back(root->data);
inorder(root->right, v);
}

TreeNode<int>* inorderToBST(int s, int e, vector<int> &v){

if(s>e){
return NULL;
}

int mid = (s+e)/2;

TreeNode<int>* root = new TreeNode<int>(v[mid]);
root->left = inorderToBST(s, mid-1, v);
root->right = inorderToBST(mid+1, e, v);
return root;
}

TreeNode<int>* balancedBst(TreeNode<int>* root) {

vector<int> v;
inorder(root, v);

return inorderToBST(0, v.size()-1, v);

}

_______________________________________________________________________Q.94)
Preorder traversal of a BST

https://www.codingninjas.com/codestudio/problems/preorder-traversal-to-bst_893111?
leftPanelTab=0

BinaryTreeNode<int>* solve(vector<int> &preorder, int mini, int maxi , int &i){

if(i>=preorder.size()){
return NULL;
}
if(preorder[i]<mini ||preorder[i]>maxi){
return NULL;
}
BinaryTreeNode<int>* root = new BinaryTreeNode<int>(preorder[i++]);
root->left = solve(preorder, mini, root->data, i);
root->right = solve(preorder, root->data, maxi, i);
return root;
}

BinaryTreeNode<int>* preorderToBST(vector<int> &preorder) {

int mini = INT_MIN;
int maxi = INT_MAX;

int i = 0;
return solve(preorder, mini, maxi, i);

________________________________________________________________________Q.95) Merge
Two BSTs

https://www.codingninjas.com/codestudio/problems/h_920474?
leftPanelTab=0&utm_source=youtube&utm_medium=affiliate&utm_campaign=Lovebabbar

_______________________________Approach 1

void inorder(TreeNode<int> *root, vector<int> &v){

if(root == NULL){
return;
}
inorder(root->left, v);
v.push_back(root->data);
inorder(root->right, v);
}

vector<int> mergeTwoBST(vector<int > v1, vector<int> v2){

vector<int> ans(v1.size()+ v2.size());
int i=0, j=0, k=0;
while(i<v1.size() && j<v2.size()){
if(v1[i] < v2[j]){
ans[k++] = v1[i];
 i++;
}
else{
ans[k++] = v2[j];
j++;
}
}
while(i < v1.size()){
ans[k++] = v1[i];
i++;
}
while(j < v2.size()){
ans[k++] = v2[j];
j++;
}
return ans;
}

TreeNode<int> * inorderToBST(int s, int e, vector <int> &mergeArray){

if(s>e){
return NULL;
}
int mid = (s+e)/2;
TreeNode<int> * ans = new TreeNode<int>(mergeArray[mid]);
ans->left = inorderToBST(s, mid-1, mergeArray);
ans->right = inorderToBST(mid+1, e, mergeArray);
return ans;

TreeNode<int> *mergeBST(TreeNode<int> *root1, TreeNode<int> *root2){

// Step 1 : store inorder
vector<int> v1, v2;

inorder(root1, v1);
inorder(root2, v2);

// step 2: Merge both sorted arrays

vector <int> mergeArray = mergeTwoBST(v1,v2);

// step 3: built bst

int s = 0;
int e = mergeArray.size()-1;
return inorderToBST(s,e , mergeArray);

____________________________Approach 2

void convertIntoSortedDLL(TreeNode<int> *root, TreeNode<int> * &head ){

// base case
if(root == NULL){
return;
}
convertIntoSortedDLL(root->right, head);
root->right = head;
 if(head != NULL){
head->left = root;
}
head = root;

convertIntoSortedDLL(root->left, head);

TreeNode<int>* mergeLinkedList(TreeNode<int> *head1, TreeNode<int> *head2){

TreeNode<int>* head = NULL;
TreeNode<int>* tail = NULL;

while(head1 != NULL && head2 != NULL){

if(head1->data < head2->data){
if(head == NULL){
head = head1;
tail = head1;
head1 = head1->right;
}
else{
tail->right = head1;
head1->left = tail;
tail = head1;
head1 = head1->right;
}
}
else{
if(head == NULL){
head = head2;
tail = head2;
head2 = head2->right;
}
else{
tail->right = head2;
head2->left = tail;
tail = head2;
head2 = head2->right;
}
}
}
while(head1 != NULL){
tail->right = head1;
head1->left = tail;
tail = head1;
head1 = head1->right;
}
while(head2 != NULL){
tail->right = head2;
head2->left = tail;
tail = head2;
head2 = head2->right;
}
return head;
}

int countNode(TreeNode<int>* &head){

int cnt = 0;
TreeNode<int>* temp = head;
 while(temp != NULL){
cnt++;
temp = temp->right;
}
return cnt;
}

TreeNode<int> * sortedLLToBST(TreeNode<int>* &head, int n){

// base case
if(n<=0 || head == NULL){
return NULL;
}

TreeNode<int>* left = sortedLLToBST(head, n/2);

TreeNode<int>* root = head;
root->left = left;
head = head->right;
root->right = sortedLLToBST(head, n-n/2-1);
return root;
}

TreeNode<int> *mergeBST(TreeNode<int> *root1, TreeNode<int> *root2){

// step 1 convert BST into sorted ll in place

TreeNode<int>* head1 = NULL;
convertIntoSortedDLL(root1, head1);
head1->left = NULL;

TreeNode<int>* head2 = NULL;

convertIntoSortedDLL(root2, head2);
head2->left = NULL;

// merge sorted ll
TreeNode<int>* head = mergeLinkedList(head1, head2);

// convert sorted ll to bst

int count = countNode(head);
return sortedLLToBST(head, count);
}

_________________________________________________________________________________Q.
96) Size of Largest BST in Binary Tree

https://www.codingninjas.com/codestudio/problems/largest-bst-subtree_893103?
leftPanelTab=0&utm_source=youtube&utm_medium=affiliate&utm_campaign=Lovebabbar

class info{
public:
int mini;
int maxi;
bool isBST;
 int size;
};

info solve(TreeNode<int>* root, int &ans){

// base case
if(root == NULL){
return {INT_MAX, INT_MIN, true, 0};
}

info left = solve(root->left, ans);

info right = solve(root->right, ans);

info currNode;

currNode.mini = min(root->data, left.mini);

currNode.maxi = max(root->data, right.maxi);
currNode.size = left.size + right.size + 1;

if (left.isBST && right.isBST &&

(root->data < right.mini && root->data > left.maxi)) {
currNode.isBST = true;
}
else{
currNode.isBST = false;
}

// answer update
if(currNode.isBST){
ans = max(ans, currNode.size);
}
return currNode;
}

int largestBST(TreeNode<int>* root)

{
int maxSize = 0;
info temp = solve(root, maxSize);
return maxSize;