C++ 二叉树（附'二叉树的镜像'算法题答案）

二叉树

• 广度遍历：队列
• 深度遍历：递归（也可以用栈来实现）

#include
#include
using namespace std;

struct TreeNode{
    int val;
    TreeNode* left;
    TreeNode* right;
    TreeNode(int value){
        this->val = value;
        this->left = nullptr;
        this->right = nullptr;
    }
};
//    1
//  2   3
// 4 5 6 7

// 前序遍历 中左右
// 1 2 4 5 3 6 7
void preOrder(TreeNode* root){
    if(root){
        cout<< root->val << endl;
        preOrder(root->left);
        preOrder(root->right);
    }
}

// 中序遍历 左中右
// 4 2 5 1 6 3 7
void inOrder(TreeNode* root){
    if(root){
        inOrder(root->left);
        cout<< root->val << endl;
        inOrder(root->right);
    }
}

// 后序遍历 左右中
// 4 5 2 6 7 3 1
void postOrder(TreeNode* root){
    if(root){
        postOrder(root->left);
        postOrder(root->right);
        cout<< root->val << endl;
    }
}

int main(){
    TreeNode* root=new TreeNode(1);
    root->left = new TreeNode(2);
    root->right = new TreeNode(3);
    root->left->left = new TreeNode(4);
    root->left->right = new TreeNode(5);
    root->right->left = new TreeNode(6);
    root->right->right = new TreeNode(7);

    preOrder(root);
    inOrder(root);
    postOrder(root);
    
    // 广度遍历
    // 1 2 3 4 5 6 7
//    queue q;
//    q.push(root);
//
//    while(!q.empty()){
//        TreeNode* tmp = q.front();
//        q.pop();
//        cout << tmp->val << endl;
//        if(tmp->left){
//            q.push(tmp->left);
//        }
//        if(tmp->right){
//            q.push(tmp->right);
//        }
//    }

}

二叉树的镜像

题目描述

操作给定的二叉树，将其变换为源二叉树的镜像。

输入描述:

二叉树的镜像定义：

		源二叉树  
    	    8
    	   /  \
    	  6   10
    	 / \  / \
    	5  7 9 11
    	镜像二叉树
    	    8
    	   /  \
    	  10   6
    	 / \  / \
    	11 9 7  5

答案

/*
struct TreeNode {
	int val;
	struct TreeNode *left;
	struct TreeNode *right;
	TreeNode(int x) :
			val(x), left(NULL), right(NULL) {
	}
};*/
class Solution {
public:
    void Mirror(TreeNode *pRoot) {
        TreeNode* tmp;
        if(pRoot){
            tmp = pRoot->left;
            pRoot->left = pRoot->right;
            pRoot->right = tmp;
            Mirror(pRoot->right);
            Mirror(pRoot->left);
        }
    }
    
};