给定一棵树和一个节点，任务是将路径反转到给定的Node并打印修改后的树的有序遍历。
例子：
Input:
7
/ \
6 5
/ \ / \
4 3 2 1
Node = 4
Output: 7 6 3 4 2 5 1
The path from root to node 4 is 7 -> 6 -> 4
Reversing this path, the modified tree will be:
4
/ \
6 5
/ \ / \
7 3 2 1
whose in-order traversal is 7 6 3 4 2 5 1
Input:
7
/ \
6 5
/ \ / \
4 3 2 1
Node = 2
Output: 4 6 3 2 7 5 1
方法：
- 首先将给定路径上的所有节点存储在队列中。
- 如果找到了密钥，则将该节点数据替换为队列数据的开头，然后弹出该开头。
- 继续以递归的方式执行此操作，直到根为止，并且路径将在原始树中反转。
- 现在，打印修改后的树的有序遍历。
下面是上述方法的实现：
C++
// C++ implementation of the approach
#include
using namespace std;
// A Binary Tree Node
struct Node {
int data;
struct Node *left, *right;
};
// Function to reverse the tree path
queue reverseTreePathUtil(Node* root, int data,
queue q1)
{
queue emptyQueue;
// If root is null then return
// an empty queue
if (root == NULL)
return emptyQueue;
// If the node is found
if (root->data == data) {
// Replace it with the queue's front
q1.push(root->data);
root->data = q1.front();
q1.pop();
return q1;
}
// Push data into the queue for
// storing data from start to end
q1.push(root->data);
// If the returned queue is empty then
// it means that the left sub-tree doesn't
// contain the required node
queue left = reverseTreePathUtil(root->left,
data, q1);
// If the returned queue is empty then
// it means that the right sub-tree doesn't
// contain the required node
queue right = reverseTreePathUtil(root->right,
data, q1);
// If the required node is found
// in the right sub-tree
if (!right.empty()) {
// Replace with the queue's front
root->data = right.front();
right.pop();
return right;
}
// If the required node is found
// in the right sub-tree
if (!left.empty()) {
// Replace with the queue's front
root->data = left.front();
left.pop();
return left;
}
// Return emptyQueue if path
// is not found
return emptyQueue;
}
// Function to call reverseTreePathUtil
// to reverse the tree path
void reverseTreePath(Node* root, int data)
{
queue q1;
// reverse tree path
reverseTreePathUtil(root, data, q1);
}
// Function to print the in-order
// traversal of the tree
void inorder(Node* root)
{
if (root != NULL) {
inorder(root->left);
cout << root->data << " ";
inorder(root->right);
}
}
// Utility function to create a new tree node
Node* newNode(int data)
{
Node* temp = new Node;
temp->data = data;
temp->left = temp->right = NULL;
return temp;
}
// Driver code
int main()
{
Node* root = newNode(7);
root->left = newNode(6);
root->right = newNode(5);
root->left->left = newNode(4);
root->left->right = newNode(3);
root->right->left = newNode(2);
root->right->right = newNode(1);
int data = 4;
// Function call to reverse the path
reverseTreePath(root, data);
// Print the in-order traversal
// of the modified tree
inorder(root);
return 0;
} Python3
# Python3 implementation of the
# above approach
# A Binary Tree Node
class Node:
def __init__(self, data):
self.data = data
self.left = None
self.right = None
# Function to reverse the
# tree path
def reverseTreePathUtil(root,
data, q1):
emptyQueue = []
# If root is null then
# return an empty queue
if (root == None):
return emptyQueue;
# If the node is found
if (root.data == data):
# Replace it with the
# queue's front
q1.append(root.data);
root.data = q1[0]
q1.pop(0);
return q1;
# Push data into the
# queue for storing
# data from start to end
q1.append(root.data);
# If the returned queue
# is empty then it means
# that the left sub-tree
# doesn't contain the
# required node
left = reverseTreePathUtil(root.left,
data, q1);
# If the returned queue is empty
# then it means that the right
# sub-tree doesn't contain the
# required node
right = reverseTreePathUtil(root.right,
data, q1);
# If the required node is found
# in the right sub-tree
if len(right) != 0:
# Replace with the queue's
# front
root.data = right[0]
right.pop(0);
return right;
# If the required node
# is found in the right
# sub-tree
if len(left) != 0:
# Replace with the
# queue's front
root.data = left[0]
left.pop(0);
return left;
# Return emptyQueue
# if path is not found
return emptyQueue;
# Function to call reverseTreePathUtil
# to reverse the tree path
def reverseTreePath(root, data):
q1 = []
# reverse tree path
reverseTreePathUtil(root,
data, q1);
# Function to print the in-order
# traversal of the tree
def inorder(root):
if (root != None):
inorder(root.left);
print(root.data,
end = ' ')
inorder(root.right);
# Utility function to create
# a new tree node
def newNode(data):
temp = Node(data)
return temp;
# Driver code
if __name__ == "__main__":
root = newNode(7);
root.left = newNode(6);
root.right = newNode(5);
root.left.left = newNode(4);
root.left.right = newNode(3);
root.right.left = newNode(2);
root.right.right = newNode(1);
data = 4;
# Function call to reverse
# the path
reverseTreePath(root, data);
# Print the in-order traversal
# of the modified tree
inorder(root);
# This code is contributed by Rutvik_56输出：
7 6 3 4 2 5 1