玩转二叉树

镜面反转二叉树并进行层序遍历的 C++ 代码如下：

#include <iostream>

#include <vector>

#include <queue>

 

using namespace std;

 

// 定义二叉树的结构体

struct TreeNode {

    int val;

    TreeNode* left;

    TreeNode* right;

};

 

// 创建二叉树节点

TreeNode* createNode(int val) {

    TreeNode* newNode = new TreeNode();

    newNode->val = val;

    newNode->left = NULL;

    newNode->right = NULL;

    return newNode;

}

 

// 打印二叉树

void printTree(TreeNode* root) {

    if (root == NULL) {

        return;

    }

    printTree(root->left);

    cout << root->val << " ";

    printTree(root->right);

}

 

// 构建二叉树

TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder, int start, int end) {

    if (start > end) {

        return NULL;

    }

 

    // 在 preorder 中找到当前节点的值

    int val = preorder[start - 1];

 

    // 在 inorder 中找到当前节点的索引

    int inorderIndex = start;

    while (inorder[inorderIndex] != val) {

        inorderIndex++;

    }

 

    // 构建左子树

    TreeNode* left = buildTree(preorder, inorder, start, inorderIndex - 1);

 

    // 构建右子树

    TreeNode* right = buildTree(preorder, inorder, inorderIndex + 1, end);

 

    // 创建当前节点

    TreeNode* root = createNode(val);

    root->left = left;

    root->right = right;

 

    return root;

}

 

// 镜面反转二叉树

void mirrorTree(TreeNode* root) {

    if (root == NULL) {

        return;

    }

 

    // 交换左子树和右子树

    TreeNode* temp = root->left;

    root->left = root->right;

    root->right = temp;

 

    // 递归反转左子树和右子树

    mirrorTree(root->left);

    mirrorTree(root->right);

}

 

// 层序遍历二叉树

void levelOrderTraversal(TreeNode* root) {

    if (root == NULL) {

        return;

    }

 

    // 创建一个队列，并将根节点入队

    queue<TreeNode*> queue;

    queue.push(root);

 

    // 层序遍历

    while (!queue.empty()) {

        int levelSize = queue.size();

 

        for (int i = 0; i < levelSize; i++) {

            TreeNode* current = queue.front();

            queue.pop();

 

            // 输出当前节点的值

            cout << current->val << " ";

 

            // 将当前节点的左右子节点入队

            if (current->left != NULL) {

                queue.push(current->left);

            }

            if (current->right != NULL) {

                queue.push(current->right);

            }

        }

        cout << endl;

    }

}

 

int main() {

    // 输入二叉树的节点个数

    int N;

    cin >> N;

 

    // 输入前序遍历序列

    vector<int> preorder;

    for (int i = 0; i < N; i++) {

        int val;

        cin >> val;

        preorder.push_back(val);

    }

 

    // 输入中序遍历序列

    vector<int> inorder;

    for (int i = 0; i < N; i++) {

        int val;

        cin >> val;

        inorder.push_back(val);

    }

 

    // 构建二叉树

    TreeNode* root = buildTree(preorder, inorder, 0, N - 1);

 

    // 打印原始二叉树

    cout << "原始二叉树: ";

    printTree(root);

 

    // 镜面反转二叉树

    mirrorTree(root);

 

    // 打印反转后的二叉树

    cout << "反转后的二叉树: ";

    printTree(root);

 

    // 层序遍历反转后的二叉树

    cout << "反转后的层序遍历: ";

    levelOrderTraversal(root);

 

    return 0;

}

 

 

在上述代码中，我们首先定义了一个 TreeNode 结构体，表示二叉树的节点。然后，我们实现了以下几个函数：

 

-  createNode ：创建一个新的二叉树节点。

 

-  printTree ：打印二叉树。

 

-  buildTree ：根据前序遍历和中序遍历序列构建二叉树。

 

-  mirrorTree ：镜面反转二叉树。

 

-  levelOrderTraversal ：层序遍历二叉树。

 

在 main 函数中，我们首先输入二叉树的节点个数和前序遍历、中序遍历序列。然后，我们使用 buildTree 函数构建原始二叉树，并使用 printTree 函数打印原始二叉树。接下来，我们调用 mirrorTree 函数进行镜面反转，并使用 printTree 函数打印反转后的二叉树。最后，我们使用 levelOrderTraversal 函数进行层序遍历，并输出反转后的层序遍历结果。

 

希望这个示例对你有帮助。如果你有任何其他问题，请随时提问。