【LeetCode】Symmetric Tree(对称二叉树)

这道题是LeetCode里的第101道题。是我在学数据结构——二叉树的时候碰见的题。

题目如下：

给定一个二叉树，检查它是否是镜像对称的。

例如，二叉树 [1,2,2,3,4,4,3] 是对称的。

     1
   /   \
  2     2
 / \   / \
3   4 4   3

但是下面这个 [1,2,2,null,3,null,3] 则不是镜像对称的:

    1
   / \
  2   2
   \   \
    3   3

说明:

你可以运用递归和迭代两种方法解决这个问题。

解题思路：

读完题目后我首先想到的是用遍历的方法来解题，树的遍历有三种：前序遍历，中序遍历和后序遍历。

这里我选择的是中序遍历，对根节点的左右子树分别进行中序遍历，但是因为要符合题目的要求——对称，所以两种中序遍历的方式不一样，根节点左子树采用LDR中序遍历，根节点右子树采用RDL中序遍历。

如同上面的两个示例：第一颗树根节点的左子树遍历结果是[3,2,4]，而根节点的右子树遍历结果是[3,2,4]，相等。对称。

第二颗树根节点的左子树遍历结果是[2,3]，而根节点的右子树遍历结果是[3,2]，不相等。不对称。

代码如下：

 /**
  * Definition for a binary tree node.
  * struct TreeNode {
  *     int val;
  *     TreeNode *left;
  *     TreeNode *right;
  *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
  * };
  */
 class Solution {
 public:
     vector<int> LPreOrder(TreeNode* tree){//LDR中序遍历
         stack<TreeNode*>st;//节点堆栈
         vector<int>res;
         TreeNode* pt;
         if(tree==NULL)return res;
         pt=tree;
         while(pt!=NULL||st.size()!=){
             while(pt!=NULL){//先访问左节点
                 st.push(pt);
                 pt=pt->left;
             }
             pt=st.top();//最下边的左节点
             res.push_back(pt->val);//保存数值
             st.pop();
             pt=pt->right;//访问右节点
         }
         return res;
     }
     vector<int> RPreOrder(TreeNode* tree){//RDL中序遍历
         stack<TreeNode*>st;
         vector<int>res;
         TreeNode* pt;
         if(tree==NULL)return res;
         pt=tree;
         while(pt!=NULL||st.size()!=){
             while(pt!=NULL){
                 st.push(pt);
                 pt=pt->right;
             }
             pt=st.top();
             res.push_back(pt->val);
             st.pop();
             pt=pt->left;
         }
         return res;
     }
     bool isSymmetric(TreeNode* root) {
         if(root==NULL)//根节点是否为空
             return true;
         if(root->left==NULL||root->right==NULL){//左右子树其中一个是否为空
             if(root->left==NULL&&root->right==NULL)//左右子树是否为空
                 return true;
             return false;
         }
         else{
             if(root->left->val!=root->right->val)return false;
             vector<int>Lorder,Rorder;
             Lorder=LPreOrder(root->left);//遍历
             Rorder=RPreOrder(root->right);//遍历
             if(Lorder!=Rorder)return false;//判断遍历结果是否相同
             return true;
         }
     }
 };

运行结果：

​​​

测试结果通过。。。

这其实这还没结束，因为如果是这颗树的话（自己突然想到的）：

​​​

很明显不对称是不是，但是仍然能通过测试，就说明在测试案例里没有这颗树。钻了个空子。

然后我没办法只好用官方解题思路：

就是使用双节点递归对每一个节点及其相对称的节点进行左右对称判断。类似于广度优先算法，或是层次遍历。

 /**
  * Definition for a binary tree node.
  * struct TreeNode {
  *     int val;
  *     TreeNode *left;
  *     TreeNode *right;
  *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
  * };
  */
 class Solution {
 public:
     bool 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->left,t2->right)
             &&isMirror(t2->left,t1->right);
     }
     bool isSymmetric(TreeNode* root) {
         return isMirror(root,root);
     }
 };

是不是看起了简单多了？我也学习到了。

个人总结：写算法不能只光顾一个案例，要善于使用各种特殊的案例来测试算法的正确性和可行性，在这里我就是在编写过程中没有充分考虑到空节点的情况，导致了多次提交的错误。