对称二叉树：BFS、DFS、递归解答

题目详见：https://leetcode-cn.com/problems/symmetric-tree/description/

二叉树结构定义

// Definition for a binary tree node.
  struct TreeNode {
      int val;
      TreeNode *left;
      TreeNode *right;
      TreeNode(int x) : val(x), left(NULL), right(NULL) {}
  };

1 BFS

思路：将每一层的数据存入队列中，按照左边的左边与右边的右边相等、左边的右边与右边的左边进行比较判断。

bool isSymmetric(TreeNode* root) {
        if(!root)return 1;
        queue<TreeNode*> cmp;
        cmp.push(root->left);
        cmp.push(root->right);//存储左右子树（对称存储）       
        while(!cmp.empty()){
            TreeNode* tmp_left=cmp.front();
            cmp.pop();
            TreeNode* tmp_right=cmp.front();
            cmp.pop();//读取左右子树
            
            if(tmp_left==NULL && tmp_right==NULL)continue;
            if(tmp_left==NULL || tmp_right==NULL)return 0;
            if(tmp_left->val !=tmp_right->val)return 0;
            cmp.push(tmp_left->left);
            cmp.push(tmp_right->right);           
            cmp.push(tmp_left->right);
            cmp.push(tmp_right->left);//按照对称进行存储
        }
        return 1;
    }

2 DFS

思路：深度遍历最左和最右的部分，并将数据依次存入栈中，从两侧向中间依次比较

bool isSymmetric(TreeNode* root) {
    if(!root) return true;
    stack<TreeNode*> sl, sr;
    sl.push(root);
    sr.push(root);//将两侧数据压入栈中
    TreeNode * lp = root->left, *rp = root->right;
    while(lp || ! sl.empty() || rp || !sl.empty()){
        if((!lp && rp) || (lp && !rp)) return false;
        if(lp && rp){
            if(lp->val != rp->val) return false;
            sl.push(lp);
            sr.push(rp);
            lp = lp->left;
            rp = rp->right; //继续向底部遍历比较
        }else{
            lp = sl.top()->right;
            rp = sr.top()->left;
            sl.pop();
            sr.pop();//遍历到叶子结点，开始往上和内部比较 
        }
    }
    return true;
}
 

 

3 递归

思路：递归的方式和BFS的思路是一致的，通过递归的方式进行表达

    bool isSymmetric(TreeNode* root) {
        if(!root)return 1;
        return cmp(root->left,root->right);
    }
    
    bool cmp(TreeNode* left,TreeNode* right){
        if(!left && !right) return 1;
        if(!left || !right)return 0;
        return (left->val==right->val) && cmp(left->left,right->right) && cmp(left->right,right->left);    
    }

解答参考：https://leetcode.com/problems/symmetric-tree/discuss/33080/Recursive-and-iterative-(DFS-and-BFS)-in-C++.-Easy-to-understand.