LeetCode 101. Symmetric Tree【树的遍历】⭐⭐⭐⭐⭐

题目描述

判断一棵树是否是对称树

知识点

树的遍历、DFS

结果

实现

码前思考

1. 我比较笨，使用的是先左边优先遍历一次，再右边优先遍历一次，判断两次结果是否相同来判断是否是对称树；（注意空结点也要进行储存，我这里用的是INT_MIN）

代码实现

//通过中序遍历来解题
//要求先序遍历和后序遍历的结果是相同的

/**
 * 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 {
private:
    vector<int> prev;
    vector<int> postv;
public:
    bool isSymmetric(TreeNode* root) {
        bool flag = true;
        preOrder(root);
        postOrder(root);
        for(int i=0;i<prev.size();i++){
            if(prev[i] != postv[i]){
                flag = false;
                break;
            }
        }
        return flag;
    }

    void preOrder(TreeNode* root){
        if(root == NULL){
            prev.push_back(INT_MIN);
        }else{
            //先序遍历
            prev.push_back(root->val);
            preOrder(root->left);
            preOrder(root->right);
        }
    }
    void postOrder(TreeNode* root){
        if(root == NULL){
            postv.push_back(INT_MIN);
        }else{
            postv.push_back(root->val);
            postOrder(root->right);
            postOrder(root->left);
        }
    }
};

码后反思

1. 其实也可以通过判断BFS结果是否是回文数来判断！也需要记录下空结点的值！
2. 其实并不需要我那么麻烦，只需要将DFS函数看作判断左右子树是否对称这样一个功能，那么就可以通过一次DFS就能判断了，网友的代码如下：

   class Solution {
   public:
       bool isSymmetric(TreeNode* root) {
           if(!root) return true;
           return dfs(root->left, root->right);
       }
   private:
       bool dfs(TreeNode* root1, TreeNode* root2){
           if(!root1 && !root2) return true;
           if(!root1 || !root2) return false;
           if(root1->val != root2->val) return false;
           return dfs(root1->left, root2->right) && dfs(root1->right, root2->left);
       }
   };
   

3. DFS一定要理解这个递归函数的意义，理解意义之后，其实还是挺好想的！

二刷代码

使用了反思里面的dfs思想，nice

/**
 * 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 flag = true;

    bool isSymmetric(TreeNode* root) {
        if(root==NULL){
            return true;
        }
        TreeNode* left = root->left;
        TreeNode* right = root->right;

        dfs(left,right);

        return flag;    
    }

    void dfs(TreeNode* left,TreeNode* right){
        if(flag==false){
            return;
        }
        if(left==NULL&&right!=NULL){
            flag = false;
            return;
        }
        if(left!=NULL&&right==NULL){
            flag=false;
            return;
        }
        if(left==NULL&&right==NULL){
            return;
        }
        //判断值
        if(left->val!=right->val){
            flag=false;
            return;
        }else{
            dfs(left->left,right->right);
            dfs(left->right,right->left);
        }
    }
};