力扣刷题笔记14—— 二叉树的镜像

问题

来自力扣：

请完成一个函数，输入一个二叉树，该函数输出它的镜像。
例如输入：

     4
   /   \
  2     7
 / \   / \
1   3 6   9
镜像输出：

     4
   /   \
  7     2
 / \   / \
9   6 3   1


示例 1：

输入：root = [4,2,7,1,3,6,9]
输出：[4,7,2,9,6,3,1]

我的代码

#include <iostream>
using namespace std;
#include <algorithm>
#include <vector>
#include<queue>
#include <typeinfo>
 struct TreeNode {
     int val;
     TreeNode *left;
     TreeNode *right;
     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 };
 
 class Solution {
 public:
	 TreeNode* mirrorTree(TreeNode* root) {
		 if (root == NULL) return NULL;
		 TreeNode* tmp = root->left;
		 root->left = mirrorNode(root->right);
		 root->right = mirrorNode(tmp);
		 return root;
	 }
	 //递归函数
	 TreeNode* mirrorNode(TreeNode* node) {
		 if (node == NULL) return NULL;
		 TreeNode* tmp = node->left;
		 node->left = mirrorNode(node->right);
		 node->right = mirrorNode(tmp);
		 return node;
	 }
	 //用于测试的函数，笔记11的那个打印函数
	 vector<int> levelOrder(TreeNode* root) {
		 vector<int> vecNode;
		 queue <TreeNode> qnode;
		 if (root != NULL)
			 qnode.push(*root);
		 while (!qnode.empty()) {
			 vecNode.push_back(qnode.front().val);
			 if (qnode.front().left != NULL)
				 qnode.push(*(qnode.front().left));
			 if (qnode.front().right != NULL)
				 qnode.push(*(qnode.front().right));
			 qnode.pop();
		 }
		 return vecNode;
	 }
 };

int main() {
	TreeNode* root=NULL;
	root = new TreeNode(3);
	root->left = new TreeNode(4);
	root->right = new TreeNode(5);
	root->left->left = new TreeNode(1);
	root->left->right = new TreeNode(2);
	root->right->left = new TreeNode(6);
	root->right->right = new TreeNode(7);
	Solution mysolution;
	TreeNode* s = mysolution.mirrorTree(root);
	vector<int> s2 = mysolution.levelOrder(s);
	for (auto iter = s2.begin(); iter != s2.end(); iter++) {
		cout << *iter << " ";
	}
	return 0;
}

我是用递归实现的，感觉这题用递归的思路是最合适的。

示例代码

class Solution {
public:
    TreeNode* mirrorTree(TreeNode* root) {
        if (!root) return root;
        queue<TreeNode*> que;   // treenode stack
        que.push(root);
        TreeNode* tmp, *node;
        while (!que.empty()) {
            node = que.front();
            que.pop();
            if (node->left) que.push(node->left);
            if (node->right) que.push(node->right);

            tmp = node->left;
            node->left = node->right;
            node->right = tmp;
        }
        return root;
    }
};

示例代码没有用递归，它用一个队列，然后每次将节点的两个子节点调换一下。其实也可以。