对称的二叉树

剑指OFFER题21------按牛客网通过率排序

时间：2018.12.19.2048
作者：Waitt

题目

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

时间限制：1秒 空间限制：32768K 热度指数：111982

解答

思路1：

中序遍历二叉树，用向量保存值(空结点用0代替)，从前后遍历向量，若有不相等的值，则说明为非对称。

/*
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};
*/
class Solution {
public:
    vector<int> a;//全局向量存贮值
    void zhon(TreeNode* pRoot)//中序遍历
    {
        if(!pRoot)
        {
            a.push_back(0);//空指针处补0
            return;
        }
        zhon(pRoot->left);
        a.push_back(pRoot->val);
        zhon(pRoot->right);
    }
    bool isSymmetrical(TreeNode* pRoot)
    {
        if(!pRoot)
            return 1;
        zhon(pRoot);//此处调用中序遍历函数
        int i=0;
        int j=a.size()-1;
        while(i<j)
        {
            if(a[i]!=a[j])
                return 0;
            i++;
            j--;
        }
        return 1;
    }
};

存在问题：当二叉树所有值均相等时，则该方法无效。

思路2

可以使用先序遍历或者后序遍历，此处以先序遍历为例：
先用先序遍历得到一种结果，再用先序遍历的对称遍历再得到一种结果。(空指针处要进行填充处理)
只有两种遍历的结果相同，则说明此树对称。
先序遍历：根、左、右。
先序遍历的对称：根、右、左。

利用额外两个向量进行判断：

/*
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};
*/
class Solution {
public:
    vector<int> a,b;// a用来保存先序遍历的结果，b用来保存先序遍历对称结果
    void xian(TreeNode* pRoot)//先序遍历函数
    {
        if(!pRoot)
        {
            a.push_back(0);//空指针处补0
            return;
        }
        a.push_back(pRoot->val);
        xian(pRoot->left);
        xian(pRoot->right);
    }
    void xid(TreeNode* pRoot)//先序遍历的对称函数
    {
        if(!pRoot)
        {
            b.push_back(0);//空指针处补0
            return;
        }
        b.push_back(pRoot->val);
        xid(pRoot->right);
        xid(pRoot->left);
    }
    bool isSymmetrical(TreeNode* pRoot)
    {
        if(!pRoot)
            return 1;
        xian(pRoot);
        xid(pRoot);
        int i=0;
        if(a.size()!=b.size())
            return 0;
        for(int i=0;i<a.size();i++)
        {
            if(a[i]!=b[i])
                return 0;
        }
        return 1;
    }
};

不利用额外向量，逐个进行对比，利用同一个树的两个指针

/*
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};
*/
class Solution {
public:
    bool fuzhu(TreeNode* pRoot1,TreeNode* pRoot2)//定义两个指针参数
    {
        if(pRoot1==NULL && pRoot2==NULL)//均为空指针时，说明两个结点相等
            return 1;
        if(pRoot1==NULL || pRoot2==NULL)//仅有一个空指针时，说明结点肯定不相等
            return 0;
        if(pRoot1->val!=pRoot2->val)//若两个结点的值相等，则进行下一步判断
            return 0;
        bool l=fuzhu(pRoot1->left,pRoot2->right);//一个结点向左，一个结点向右
        bool r=fuzhu(pRoot2->left,pRoot1->right);//与上一步对称
        return l&&r;
    }
    bool isSymmetrical(TreeNode* pRoot)
    {
        if(!pRoot)
            return 1;
        return fuzhu(pRoot,pRoot);
    }

};

TIPS

广度优先搜索(BFS)与深度优先搜索(DFS)
深度优先搜索用栈（stack）来实现，整个过程可以想象成一个倒立的树形：
1、把根节点压入栈中。
2、每次从栈中弹出一个元素，搜索所有在它下一级的元素，把这些元素压入栈中。并把这个元素记为它下一级元素的前驱。
3、找到所要找的元素时结束程序。
4、如果遍历整个树还没有找到，结束程序。

广度优先搜索使用队列（queue）来实现，整个过程也可以看做一个倒立的树形：
1、把根节点放到队列的末尾。
2、每次从队列的头部取出一个元素，查看这个元素所有的下一级元素，把它们放到队列的末尾。并把这个元素记为它下一级元素的前驱。
3、找到所要找的元素时结束程序。
4、如果遍历整个树还没有找到，结束程序。