- Trending Categories
Data Structure
Networking
RDBMS
Operating System
Java
MS Excel
iOS
HTML
CSS
Android
Python
C Programming
C++
C#
MongoDB
MySQL
Javascript
PHP
Physics
Chemistry
Biology
Mathematics
English
Economics
Psychology
Social Studies
Fashion Studies
Legal Studies
- Selected Reading
- UPSC IAS Exams Notes
- Developer's Best Practices
- Questions and Answers
- Effective Resume Writing
- HR Interview Questions
- Computer Glossary
- Who is Who
C++ Reverse a path in BST using queue
Given a binary search tree, and we are required to reverse its path from a particular key, for example.
Approach to Find the Solution
In this approach, we will make a queue and push all the nodes until we get the root.
Example
#include <bits/stdc++.h>
using namespace std;
struct node {
int key;
struct node *left, *right;
};
struct node* newNode(int item){
struct node* temp = new node;
temp->key = item;
temp->left = temp->right = NULL;
return temp;
}
void inorder(struct node* root){
if (root != NULL) {
inorder(root->left);
cout << root->key << " ";
inorder(root->right);
}
}
void Reversing(struct node** node,
int& key, queue<int>& q1){
/* If the tree is empty then
return*/
if (node == NULL)
return;
if ((*node)->key == key){ // if we find the key
q1.push((*node)->key); // we push it into our queue
(*node)->key = q1.front(); // we change the first queue element with current
q1.pop(); // we pop the first element
}
else if (key < (*node)->key){ // if key is less than current node's value
q1.push((*node)->key); // we push the element in our queue
Reversing(&(*node)->left, key, q1); //we go to the left subtree using a recursive call
(*node)->key = q1.front(); //we reverse the elements
q1.pop(); // we pop the first element
}
else if (key > (*node)->key){ // if key greater than node key then
q1.push((*node)->key);// we push node key into queue
Reversing(&(*node)->right, key, q1);// we go to right subtree using a recursive call
(*node)->key = q1.front();// replace queue front to node key
q1.pop(); // we pop the first element
}
return;
}
struct node* insert_node(struct node* node, // function to insert node nodes in our BST
int key){
if (node == NULL)
return newNode(key); // if tree is empty we return a new node
if (key < node->key) // else we push that in our tree
node->left = insert_node(node->left, key);
else if (key > node->key)
node->right = insert_node(node->right, key);
return node; // returning the node
}
int main(){
struct node* root = NULL;
queue<int> q1;
int k = 80;
/****************Creating the BST*************************/
root = insert_node(root, 50);
insert_node(root, 30);
insert_node(root, 20);
insert_node(root, 40);
insert_node(root, 70);
insert_node(root, 60);
insert_node(root, 80);
cout << "Before Reversing :" << "\n";
inorder(root);
cout << "\n";
Reversing(&root, k, q1);
cout << "After Reversing :" << "\n";
// print inorder of reverse path tree
inorder(root);
return 0;
}Output
Before Reversing : 20 30 40 50 60 70 80 After Reversing : 20 30 40 80 60 70 50
Explanation of the Above Code
In this approach, we are simply going to search for the given key. As we go through the tree, we push all the nodes in a queue, and now when we find the node with a value of the key, we swap all the path nodes’ values who queue in front, and in this process, our path becomes reversed.
Conclusion
We solve a problem to Reverse a path in BST using a queue and using recursion. We also learned the C++ program for this problem and the complete approach (Normal) by which we solved this problem. We can write the same program in other languages such as C, java, python, and other languages. We hope you find this tutorial helpful.
80 Views
