Given a Binary tree, the task is to sort the particular path from to a given node of the binary tree. You are given a Key Node and Tree. The task is to sort the path till that particular node.

**Examples**:

Input: 3 / \ 4 5 / \ \ 1 2 6 key = 2Output: 2 / \ 3 5 / \ \ 1 4 6 Inorder :- 1 3 4 2 5 6 Here the path from root to given key is sorted from 3(root) to 2(key).Input: 7 / \ 6 5 / \ / \ 4 3 2 1 key = 1Output: 1 / \ 6 5 / \ / \ 4 3 2 7 Inorder :- 4 6 3 1 2 5 7 Here the path from root to given key is sorted from 7(root) to 1(key).

**Algorithm**: Following is simple algorithm to sort the path top to bottom (increasing order).

- Find path from root to given key node and store it in a priority queue.
- Replace the value of node with the priority queue top element.
- if left pq size is greater than replace the value of node with left pq after pop out the element.
- if right pq size is greater then replace the value of node with right pq after pop out the element.
- Print the tree in inorder.

Below is the implementation of the above approach:

`// CPP program to sort the path from root to` `// given node of a binary tree` ` ` `#include <iostream>` `#include <queue>` `using` `namespace` `std;` ` ` ` ` `// Binary Tree node` `struct` `Node {` ` ` `int` `data; ` `// store data` ` ` `Node *left, *right; ` `// left right pointer` `};` ` ` `/* utility that allocates a new Node ` `with the given key */` `Node* newNode(` `int` `data)` `{` ` ` `Node* node = ` `new` `Node;` ` ` `node->data = data;` ` ` `node->left = node->right = NULL;` ` ` `return` `(node);` `}` ` ` `// Function to find the inorder traversal` `void` `inorder(` `struct` `Node* root)` `{` ` ` `// base condition` ` ` `if` `(root == NULL)` ` ` `return` `;` ` ` ` ` `// go to left part` ` ` `inorder(root->left);` ` ` ` ` `// print the data` ` ` `cout << root->data << ` `" "` `;` ` ` ` ` `// go to right part` ` ` `inorder(root->right);` `}` ` ` `priority_queue<` `int` `> solUtil(Node* root, ` `int` `key, ` ` ` `priority_queue<` `int` `> pq)` `{` ` ` `priority_queue<` `int` `> blank;` ` ` ` ` `// if node is not found` ` ` `// then we will return` ` ` `// blank priority queue` ` ` `if` `(root == NULL)` ` ` `return` `blank;` ` ` ` ` `// store the path in priority queue` ` ` `pq.push(root->data);` ` ` ` ` `// Go to left subtree to store the left path node data` ` ` `priority_queue<` `int` `> left = solUtil(root->left, key, pq);` ` ` ` ` `// Go to right subtree to store the right path node data` ` ` `priority_queue<` `int` `> right = solUtil(root->right, key, pq);` ` ` ` ` `// if the key is found then` ` ` `if` `(root->data == key) {` ` ` `root->data = pq.top();` ` ` `pq.pop();` ` ` `return` `pq;` ` ` `}` ` ` `else` `if` `(left.size()) ` `// if the node in path then` ` ` `{ ` `// we change the root node data` ` ` `root->data = left.top();` ` ` `left.pop();` ` ` `return` `left;` ` ` `}` ` ` `else` `if` `(right.size()) ` `// if the node in path then` ` ` `{ ` `// we change the root node data` ` ` `root->data = right.top();` ` ` `right.pop();` ` ` `return` `right;` ` ` `}` ` ` ` ` `// if no key node found` ` ` `// then return blank` ` ` `// priority_queue` ` ` `return` `blank;` `}` ` ` `// Function to sort path from ` `// root to a given key node` `void` `sortPath(Node* root, ` `int` `key)` `{` ` ` `// for store the data` ` ` `// in a sorted manner` ` ` `priority_queue<` `int` `> pq;` ` ` ` ` `// call the solUtil function` ` ` `// sort the path` ` ` `solUtil(root, key, pq);` `}` ` ` `// Driver Code` `int` `main()` `{` ` ` `/* 3 ` ` ` `/ \ ` ` ` `4 5 ` ` ` `/ \ \ ` ` ` `1 2 6 */` ` ` ` ` `// Build the tree` ` ` `// given data` ` ` `Node* root = newNode(3);` ` ` `root->left = newNode(4);` ` ` `root->right = newNode(5);` ` ` `root->left->left = newNode(1);` ` ` `root->left->right = newNode(2);` ` ` `root->right->right = newNode(6);` ` ` ` ` `// given key` ` ` `int` `key = 1;` ` ` ` ` `// Call the function to` ` ` `// sort the path till given key tree` ` ` `sortPath(root, key);` ` ` ` ` `// call the function to print tree` ` ` `inorder(root);` ` ` ` ` `return` `0;` `}` |

Output:-

1 3 4 2 5 6

**Time Complexity**: O(N logN) [N for traversing all the node and N*logN for priority queue]

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the **DSA Self Paced Course** at a student-friendly price and become industry ready. To complete your preparation from learning a language to DS Algo and many more, please refer **Complete Interview Preparation Course****.**

In case you wish to attend live classes with industry experts, please refer **Geeks Classes Live**