剑指offer编程题—对称的二叉树

题目描述
请实现一个函数，用来判断一颗二叉树是不是对称的。注意，如果一个二叉树同此二叉树的镜像是同样的，定义其为对称的。

解题思路：
递归思想实现，首先分两种情况进行考虑：

1. 树为空，直接返回true；
2. 树不为空，则转去判断左子树和右子树是否对称，分以下两种情况进行讨论：
   a. 左子树和右子树都为空，直接返回true；
   b. 左子树和右子树都不为空，并且左子树和右子树根节点的值相等，递归判断左子树的左子树和右子树的右子树是否对称，以及左子树的右子树和右子树的左子树是否对称，返回二者与的结果；
   c. 以上两种情况不满足时，直接返回false。

代码实现：

/*
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};
*/
class Solution {
public:
    bool isSymmetrical(TreeNode* pRoot)
    {
        if(pRoot==NULL){
            return true;
        }
        return equalLR(pRoot->left,pRoot->right);
    }
    bool equalLR(TreeNode* l,TreeNode* r){
        if(l==NULL && r==NULL)
            return true;
        if(l && r){
            if(l->val!=r->val){
                return false;
            }
            else{
                return equalLR(l->left,r->right) && equalLR(l->right,r->left);
            }
        }
        return false;
    }
};

非递归实现：

1. 使用两个栈辅助

/*
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};
*/
class Solution {
public:
    bool isSymmetrical(TreeNode* pRoot)
    {
        if(pRoot==NULL){
            return true;
        }
        if(!pRoot->left && !pRoot->right){
            return true;
        }
        if(pRoot->left && pRoot->right){
            stack<TreeNode*> l,r;
            l.push(pRoot->left);
            r.push(pRoot->right);
            while(!l.empty() && !r.empty()){
                TreeNode* lc=l.top();
                l.pop();
                TreeNode* rc=r.top();
                r.pop();
                if(lc->val != rc->val){
                    return false;
                }
                if(lc->left && rc->right){
                    l.push(lc->left);
                    r.push(rc->right);
                }
                else if(lc->left || rc->right)
                    return false;
                if(lc->right && rc->left){
                    l.push(lc->right);
                    r.push(rc->left);
                }
                else if(lc->right || rc->left)
                    return false;
            }
            if(l.empty() && r.empty()){
                return true;
            }
            return false;
        }
        return false;
    }
};

2. 使用一个栈辅助实现

/*
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};
*/
class Solution {
public:
    bool isSymmetrical(TreeNode* pRoot)
    {
        if(pRoot==NULL){
            return true;
        }
        stack<TreeNode*> v;
        v.push(pRoot->left);
        v.push(pRoot->right);
        while(!v.empty()){
            TreeNode* lc=v.top();
            v.pop();
            TreeNode* rc=v.top();
            v.pop();
            if(lc==NULL && rc==NULL)
                continue;
            if(lc==NULL || rc==NULL)
                return false;
            if(lc->val!=rc->val)
                return false;
            v.push(lc->left);
            v.push(rc->right);
            v.push(lc->right);
            v.push(rc->left);
        }
        return true;
    }
};