【二叉树2】102. 二叉树的层序遍历 226.翻转二叉树 101. 对称二叉树

二叉树的层序遍历

算法

层序遍历利用了队列。
1.从root开始，第一层只有root一个元素，root进队列，记录此时que的大小。
然后弹出root，将root的值记录在res数组中，root的左右子树进队列。
2.记录此时que大小。对此时que中的每个节点，都先出列，记录值，然后将左右节点进队列。
3.size记录的是当前遍历层的节点个数。虽然有时候会出现两层的节点同时都在队列里的情况（处理了该层的第一个节点，将她的左右子树压入队列，但是还未处理该层的第二个节点的时候），但是有size作为一个计数器，就可以准确地只处理这一层的节点。

递归同样可以实现层序遍历。
1.确定参数和返回值
参数就是，当前节点cur，记录结果的数组，还有当前遍历到的深度。
返回值为void
2.确认终止条件
还是遍历到叶子结点的时候，也就是cur为空的时候，返回。
3.确认层内逻辑
每当遍历到该层的第一个节点的时候，vector<vector>res需要推入一个新的vector,不然等会往里面填充值的时候就会报错。（怎么确定？就是看vector<vector>res的大小和depth的关系，由于depth从0开始，res的大小从1开始，所以res应当比depth大1，如果相等，说明res需要++）
然后将当前的cur的值推入res中。
然后开始递归，将左右节点填入递归函数中。

102. 二叉树的层序遍历

链接

https://leetcode.cn/problems/binary-tree-level-order-traversal/description/

思路

就是层序遍历

代码

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        queue<TreeNode*> que;
        vector<vector<int>> result;
        if(root == NULL) return result;
        que.push(root);
        while(!que.empty()){
            int size = que.size();
            vector<int> v;
            for(int i = 0; i < size; i++){
                TreeNode *node = que.front();
                v.push_back(node->val);
                que.pop();
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
            }
            result.push_back(v);
        }
        return result;
    }
};

递归：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    void travelsal(TreeNode *cur, vector<vector<int>>& result, int depth){
        if(cur == NULL) return;
        if(result.size() == depth) result.push_back(vector<int>());
        result[depth].push_back(cur->val);
        travelsal(cur->left, result, depth+1);
        travelsal(cur->right, result, depth+1);
    }
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> result;
        travelsal(root, result, 0);
        return result;
    }
};

107.二叉树的层次遍历 II

链接

https://leetcode.cn/problems/binary-tree-level-order-traversal-ii/description/

思路

只要求输出其节点值 自底向上的层序遍历 。 （即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历），也就是说，每一层内的没有反，只不过是层之间的顺序调转了。那在最后reverse一下result数组就行。

代码

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
//  struct TreeNode{
//     int val;
//     TreeNode *left;
//     TreeNode *right;
//     TreeNode() : val(0), left(nullptr), right(nullptr) {}
//     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
//     TreeNode(int x, TreeNode* left, TreeNode* right) : val(x), left(left), right(right) {}
//  };
class Solution {
public:
    vector<vector<int>> levelOrderBottom(TreeNode* root) {
        vector<vector<int>> result;
        queue<TreeNode*> que;
        if(root == NULL) return result;
        que.push(root);
        while(!que.empty()){
            int size = que.size();
            vector<int> vec;
            for(int i = 0; i < size; i++){
                TreeNode *node = que.front();
                que.pop();
                vec.push_back(node->val);
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
            }
            result.push_back(vec);
        }
        reverse(result.begin(), result.end());
        return result;
    }
};

99.二叉树的右视图

链接

https://leetcode.cn/problems/binary-tree-right-side-view/

思路

右边能看到的元素，其实就是最右边的所有元素，那么就是每一层的最后一个元素，那么在for循环的时候判断一下就行，是最后一个元素才记录res。

代码

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
// struct TreeNode {
//     int val;
//     TreeNode *left;
//     TreeNode *right;
//     TreeNode() : val(0), left(nullptr), right(nullptr) {}
//     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
//     TreeNode(int x, TreeNode* left, TreeNode* right) : val(x), left(left), right(right) {}
// };
class Solution {
public:
    vector<int> rightSideView(TreeNode* root) {
        vector<int> result;
        queue<TreeNode*> que;
        if(root == NULL) return result;
        que.push(root);
        while(!que.empty()){
            int size = que.size();
            for(int i = 0; i < size; i++){
                TreeNode *node = que.front();
                que.pop();
                if(i == size-1) result.push_back(node->val);
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
            }
        }
        return result;
    }
};

637.二叉树的层平均值

链接

https://leetcode.cn/problems/average-of-levels-in-binary-tree/

思路

每层求平均值就行
注意如果要求两个整数相除之后的小数结果，提前把一个整数变成double会比较有效，而不是在除的时候再用double（）转换，不然可能会超时。

代码

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
//  struct TreeNode {
//     int val;
//     TreeNode *left;
//     TreeNode *right;
//     TreeNode() : val(0), left(nullptr), right(nullptr) {}
//     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
//     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
//  };
class Solution {
public:
    vector<double> averageOfLevels(TreeNode* root) {
        vector<double> result;
        queue<TreeNode*> que;
        if(root == NULL) return result;
        que.push(root);
        while(!que.empty()){
            int size = que.size();
            double sum = 0;
            for(int i = 0; i < size; i++){
                TreeNode *node = que.front();
                que.pop();
                sum += node->val;
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
            }
            result.push_back(sum/size);
        }
        return result;
    }
};

429.N叉树的层序遍历

链接

https://leetcode.cn/problems/n-ary-tree-level-order-traversal/

思路

其实就是定义改了一下，按照定义方式，在push子节点进入队列的时候改用循环就好了。

代码

/*
// Definition for a Node.
class Node {
public:
    int val;
    vector<Node*> children;

    Node() {}

    Node(int _val) {
        val = _val;
    }

    Node(int _val, vector<Node*> _children) {
        val = _val;
        children = _children;
    }
};
*/

// class Node {
// public:
//     int val;
//     vector<Node*> children;

//     Node() {}

//     Node(int x) {val = x}

//     Node(int x, vector<Node*> children){
//         val = x;
//         children = children;
//     }
// }

class Solution {
public:
    vector<vector<int>> levelOrder(Node* root) {
        queue<Node*> que;
        vector<vector<int>> result;
        if(root == NULL) return result;
        que.push(root);
        while(!que.empty()){
            int size = que.size();
            vector<int> v;
            for(int i = 0; i < size; i++){
                Node *node = que.front();
                v.push_back(node->val);
                que.pop();
                for(int j = 0; j < node->children.size(); j++){
                    if(node->children[j]) que.push(node->children[j]);
                }
            }
            result.push_back(v);
        }
        return result;
    }
};

515.在每个树行中找最大值

链接

https://leetcode.cn/problems/find-largest-value-in-each-tree-row/

思路

每层记录最大值就行，注意这题val可能是负数，设置max值的时候初始化为INT_MIN比较好。

代码

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<int> largestValues(TreeNode* root) {
        queue<TreeNode*> que;
        vector<int> result;
        if(root == NULL) return result;
        que.push(root);
        while(!que.empty()){
            int size = que.size();
            int max = INT_MIN;
            for(int i = 0; i < size; i++){
                TreeNode *node = que.front();
                if(node->val > max) max = node->val;
                que.pop();
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
            }
            result.push_back(max);
        }
        return result;
    }
};

116.填充每个节点的下一个右侧节点指针

链接

https://leetcode.cn/problems/populating-next-right-pointers-in-each-node/description/

思路

在for循环中让当前node指向当前队列的front就行，这个就是同层的下一个节点，如果是该层的最后一个节点的话就指向空。

代码

/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* left;
    Node* right;
    Node* next;

    Node() : val(0), left(NULL), right(NULL), next(NULL) {}

    Node(int _val) : val(_val), left(NULL), right(NULL), next(NULL) {}

    Node(int _val, Node* _left, Node* _right, Node* _next)
        : val(_val), left(_left), right(_right), next(_next) {}
};
*/

class Solution {
public:
    Node* connect(Node* root) {
        queue<Node*> que;
        if(root == NULL) return root;
        que.push(root);
        while(!que.empty()){
            int size = que.size();
            for(int i = 0; i < size; i++){
                Node *node = que.front();
                que.pop();
                if (i != size-1){
                    node->next = que.front();
                }else{
                    node->next = NULL;
                }
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
            }
        }
        return root;
    }
};

117.填充每个节点的下一个右侧节点指针II

链接

https://leetcode.cn/problems/populating-next-right-pointers-in-each-node-ii/description/

思路

和上一题没有任何区别，如果用层序遍历的话，代码一模一样

代码

/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* left;
    Node* right;
    Node* next;

    Node() : val(0), left(NULL), right(NULL), next(NULL) {}

    Node(int _val) : val(_val), left(NULL), right(NULL), next(NULL) {}

    Node(int _val, Node* _left, Node* _right, Node* _next)
        : val(_val), left(_left), right(_right), next(_next) {}
};
*/

class Solution {
public:
    Node* connect(Node* root) {
        queue<Node*> que;
        if(root == NULL) return root;
        que.push(root);
        while(!que.empty()){
            int size = que.size();
            for(int i = 0; i < size; i++){
                Node *node = que.front();
                que.pop();
                if (i != size-1){
                    node->next = que.front();
                }else{
                    node->next = NULL;
                }
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
            }
        }
        return root;
    }
};

104.二叉树的最大深度

链接

https://leetcode.cn/problems/maximum-depth-of-binary-tree/description/

思路

while循环的次数就是深度

代码

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    int maxDepth(TreeNode* root) {
        queue<TreeNode*> que;
        int depth = 0;
        if(root == NULL) return depth;
        que.push(root);
        while(!que.empty()){
            int size = que.size();
            depth++;
            for(int i = 0; i < size; i++){
                TreeNode *node = que.front();
                que.pop();
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
            }
        }
        return depth;
    }
};

111.二叉树的最小深度

链接

https://leetcode.cn/problems/minimum-depth-of-binary-tree/description/

思路

当左右节点都是null的时候就是叶子结点，然后返回当前的深度就好。

代码

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    int minDepth(TreeNode* root) {
        queue<TreeNode*> que;
        int min_level = 0;
        if(root == NULL) return min_level;
        que.push(root);
        while(!que.empty()){
            int size = que.size();
            min_level++;
            for(int i = 0; i < size; i++){
                TreeNode *node = que.front();
                que.pop();
                if(node->left || node->right)
                {
                    if(node->left) que.push(node->left);
                    if(node->right) que.push(node->right);
                }else{
                    return min_level;
                }
            }
        }
        return min_level;
    }
};

226.翻转二叉树

题目链接

（1）文字讲解：https://programmercarl.com/0226.翻转二叉树.html#算法公开课
（2）视频讲解：
（3）题目链接：https://leetcode.cn/problems/invert-binary-tree/description/

看到题解之前的想法

递归，其实只要反转每一个节点的左右子树就能完成效果，所以使用递归法，每个节点交换左右子树就行

看到题解之后的想法

递归：
前后可以，但是中序不行，因为因为中序遍历会使左子树反转两次而右子树没有反转（请画图，反正自顶向下或者自底向上都可以，但是不能一下自顶向下一下自底向上）
但是强行做也行，那就是翻转左子树两次。。

class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        if (root == NULL) return root;
        invertTree(root->left);         // 左
        swap(root->left, root->right);  // 中
        invertTree(root->left);         // 注意 这里依然要遍历左孩子，因为中间节点已经翻转了
        return root;
    }
};

迭代法：
上次介绍了前序遍历、后序遍历、中序遍历的迭代法，其实也可以用这个来做
至于为什么迭代法的中序遍历就能做，是因为迭代法用的是栈，就算swap了左右节点，已经存在栈中的顺序是不会变的；但是递归法用的是指针，swap了左右节点之后指针的指向变了！所以这两种方法是不一样的。
并且只有统一迭代法的中序遍历能行，因为统一迭代法同时把一个节点的左右子树都存进了栈里，但是迭代法的中序遍历，只存了左子树，所以，如果硬要写，只能这样写：
中序遍历迭代法：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        stack<TreeNode*> st;
        if(root == NULL) return root;
        TreeNode* cur = root;
        while(cur!= NULL || !st.empty()){
            if(cur){
                st.push(cur);
                cur = cur->left;
            }else{
                cur = st.top();
                swap(cur->left, cur->right);
                st.pop();
                // 注意这里！不是right，因为这个时候已经反转了
                cur = cur->left;
            }
        }
        return root;
    }
};

本题难点

掌握各种写法

代码

递归法：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
void travelsal(TreeNode* cur){
    if(cur == NULL) return;
    TreeNode* tmp = cur->left;
    cur->left = cur->right;
    cur->right = tmp;
    travelsal(cur->left);
    travelsal(cur->right);
}
    TreeNode* invertTree(TreeNode* root) {
        travelsal(root);
        return root;
    }
};

迭代法：
前序遍历：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        stack<TreeNode*> st;
        if(root == NULL) return root;
        st.push(root);
        while(!st.empty()){
            TreeNode* node = st.top();
            st.pop();
            swap(node->left, node->right);
            // 这里left和right的顺序无所谓了，因为这里的左子树和右子树就是自己反转自己的，不影响同层的其他节点，所以反转先后就无所谓了
            if(node->right) st.push(node->right);
            if(node->left) st.push(node->left);
        }
        return root;
    }
};

统一迭代法（前序）：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        stack<TreeNode*> st;
        if(root == NULL) return root;
        st.push(root);
        TreeNode* cur = root;
        while(!st.empty()){
            cur = st.top();
            if(cur){
                st.pop();
                if(cur->right) st.push(cur->right);
                if(cur->left) st.push(cur->left);
                st.push(cur);
                st.push(NULL);
            }else{
                st.pop();
                cur = st.top();
                st.pop();
                swap(cur->left, cur->right);
            }
        }

        return root;
    }
};

统一迭代法（中序）：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        stack<TreeNode*> st;
        if(root == NULL) return root;
        st.push(root);
        TreeNode* cur = root;
        while(!st.empty()){
            cur = st.top();
            if(cur){
                st.pop();
                if(cur->right) st.push(cur->right);
                st.push(cur);
                st.push(NULL);
                if(cur->left) st.push(cur->left);
            }else{
                st.pop();
                cur = st.top();
                st.pop();
                swap(cur->left, cur->right);
            }
        }

        return root;
    }
};

层序遍历迭代：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        queue<TreeNode*> que;
        if(root == NULL) return root;
        que.push(root);
        while(!que.empty()){
            int size = que.size();
            for(int i = 0; i< size; i++){
                TreeNode* node = que.front();
                que.pop();
                swap(node->left, node->right);
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
            }
        }
        return root;
    }
};

101. 对称二叉树

题目链接

（1）文字讲解：https://programmercarl.com/0101.对称二叉树.html#思路
（2）视频讲解：
（3）题目链接：https://leetcode.cn/problems/symmetric-tree/description/

看到题解之前的想法

不会写，因为他是镜像对比

看到题解之后的想法

递归法：
1.确定参数和返回值
既然是比较是否相同，那返回值应该是bool，参数是两个被比较的左右节点
2.确定终止条件
能确定的终止条件有好几种
（1）两个节点都为空，那返回true，表示比较到这里的时候两者还是相等的
（2）一个节点为空一个节点为非空 那直接返回false
（3）两个节点非空，但是值不一样，那返回false
剩下的就是两个节点的值一样了，那就要进下一层递归了，比他们的孩子
3.确定层内逻辑
层内逻辑就是比孩子，但是注意，是镜像地比，外层两个比，内层两个比
bool out_compare = compare(left->left, right->right);
bool in_compare = compare(left->right, right->left);
不要写错了。

迭代法：
利用queue来存一对需要比较的对象，每次存两个，每次check的时候也check两个，这样就能保证在que里的永远都是需要被比较的两个节点。(其实用栈也可以的，就是出栈顺序不一样，注意一下就行)

本题难点

代码

递归

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
bool compare(TreeNode* left, TreeNode* right){
    if(!left && !right) return true;
    else if((!left&&right)||(!right&&left)) return false;
    else if(left && right && left->val != right->val) return false;
    bool out_compare = compare(left->left, right->right);
    bool in_compare = compare(left->right, right->left);
    return out_compare && in_compare;
}
    bool isSymmetric(TreeNode* root) {
        if(root == NULL) return true;
        return compare(root->left, root->right);
    }
};

迭代：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    bool isSymmetric(TreeNode* root) {
        queue<TreeNode*> que;
        if(root == NULL) return true;
        que.push(root->left);
        que.push(root->right);
        while(!que.empty()){
            TreeNode* l = que.front();
            que.pop();
            TreeNode* r = que.front();
            que.pop();
            if(!l & !r) continue;
            else if((!l && r) || (l && !r)) return false;
            else if(l->val != r->val) return false;
            que.push(l->left);
            que.push(r->right);
            que.push(l->right);
            que.push(r->left);
        }
        return true;
    }
};

栈：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    bool isSymmetric(TreeNode* root) {
        stack<TreeNode*> st;
        if(root == NULL) return true;
        st.push(root->left);
        st.push(root->right);
        while(!st.empty()){
            TreeNode* r = st.top();
            st.pop();
            TreeNode* l = st.top();
            st.pop();
            if(!l & !r) continue;
            else if((!l && r) || (l && !r)) return false;
            else if(l->val != r->val) return false;
            st.push(l->left);
            st.push(r->right);
            st.push(l->right);
            st.push(r->left);
        }
        return true;
    }
};