101.[Leetcode]Symmetric Tree

题意：

判断一个二叉树是不是对称的

我的思路：

递归

但是不是一般的那种递归，那种递归我是想不出来的，因为觉得子节点是否是对称和父节点着实没什么关系。

我用递归遍历一个节点的左右节点，并记录在栈里，同时遍历其右左（顺序相反）记录在栈

之后比较两个栈即刻。节点为空要置为 -1，一个不会再val出现的值 非常重要

注意：边际条件，根为空的时候返回true；

//第一种方法坑定是递归，但是不是一般的递归，一般的递归我还真想不出来
class Solution {
public:
    bool isSymmetric(TreeNode* root) {
        //边际条件一定要注意
        if(root == NULL) return true;
        stack<int> vals_1,vals_2;
        push_val(root->left,vals_1,1);
        push_val(root->right,vals_2,0);
        while(!vals_1.empty()){
           if(vals_2.empty()) return false; //vals_1没空，而vals_2却空了，数量上就不对成了
           if(vals_1.top() != vals_2.top()) return false; //不相等，false
           vals_1.pop();
           vals_2.pop();
        }
        if(!vals_2.empty()) return false; // 同理
        return true;
    }

    void push_val(TreeNode* node,stack<int> &vals,int direction){ //引用是个好东西,先左后右的顺序将node的val朴实进去
        if(node == NULL) {
            vals.push(-1); //经可能最大数，或者负数，看测试用例的情况吧
            return;
        }
        vals.push(node->val);
        if(direction == 1) {
            push_val(node->left,vals,1);
            push_val(node->right,vals,1);
        } else {
            push_val(node->right,vals,0);
            push_val(node->left,vals,0);
        }
    }
};

给出的官方递归也是叹为观止：

分析的很对，两个树镜像无非是两个元素：1. 这两个根节点相等 2. 节点1的左子节点和节点2的右子节点镜像，节点1的右子节点和节点2的左子节点镜像，

public boolean isSymmetric(TreeNode root) {
    return isMirror(root, root);
}

public boolean isMirror(TreeNode t1, TreeNode t2) {
    if (t1 == null && t2 == null) return true;
    if (t1 == null || t2 == null) return false;
    return (t1.val == t2.val)
        && isMirror(t1.right, t2.left)
        && isMirror(t1.left, t2.right);
}

第二种方法当然是循环，二叉树的遍历前序，中序，后序如何用循环实现，在这个链接下解释的还是很清楚的，复习一下

class Solution {
public:
    bool isSymmetric(TreeNode* root) {
        //边界条件
        if(root == NULL) return true; //root为空
        if(root->left == NULL && root->right == NULL) return true; //root无节点
        if(!(root->left != NULL && root->right != NULL)) return false; //root只有一个节点

        stack<TreeNode*> nodes; //用来存储节点信息
        nodes.push(root->left);
        nodes.push(root->right);
        while(!nodes.empty()){
            //v
            TreeNode* node1 = nodes.top();
            nodes.pop();
            TreeNode* node2 = nodes.top();
            nodes.pop();

            if(node1->val != node2->val) return false; //judge

            // left,right
            if((node1->left == NULL && node2->right != NULL) || (node1->left != NULL && node2->right == NULL))
            return false;
            if(node1->left != NULL && node2->right != NULL) {
                nodes.push(node1->left);
                nodes.push(node2->right);
            }
            // right,left
            if((node2->left == NULL && node1->right != NULL) || (node2->left != NULL && node1->right == NULL))
            return false;
            if(node2->left != NULL && node1->right != NULL) {
                nodes.push(node2->left);
                nodes.push(node1->right);
            }
        }

        return true;
    }
};