代码随想录第十二天|226.翻转二叉树...

226.翻转二叉树

class Solution {
public:
    void reverseTree(TreeNode* &root){
        if(root->left==NULL&&root->right==NULL){
             return;
        }else{
             TreeNode *temp=root->left;
             root->left=root->right;
             root->right=temp;
             if(root->left!=NULL)
               reverseTree(root->left);
             if(root->right!=NULL)
              reverseTree(root->right);
        }
    }
    TreeNode* invertTree(TreeNode* root) {
          if(root==NULL)
             return NULL;
        reverseTree(root);
        return root;
    }
};

101.对称二叉树

class Solution {
public:
    bool compare(TreeNode* left, TreeNode* right) {
        // 首先排除空节点的情况
        if (left == NULL && right != NULL) return false;
        else if (left != NULL && right == NULL) return false;
        else if (left == NULL && right == NULL) return true;
        // 排除了空节点，再排除数值不相同的情况
        else if (left->val != right->val) return false;

        // 此时就是：左右节点都不为空，且数值相同的情况
        // 此时才做递归，做下一层的判断
        bool outside = compare(left->left, right->right);   // 左子树：左、 右子树：右
        bool inside = compare(left->right, right->left);    // 左子树：右、 右子树：左
        bool isSame = outside && inside;                    // 左子树：中、 右子树：中 （逻辑处理）
        return isSame;

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

思路：看了题解明白的 递归三部曲 对称比较 left right变量

单层递归逻辑 如果left等于right了 比较外层结点和内层节点 返回与操作

class Solution {
public:
    int maxDepth(TreeNode* root) {
          int dep=0;
          queue<TreeNode *> q;
          if(root==NULL)
            return 0;
          q.push(root);
          while(!q.empty()){
              dep++;
              int size=q.size();
              for(int i=0;i<size;i++){
                TreeNode *now=q.front();
                q.pop();
                if(now->left!=NULL)
                  q.push(now->left);
                if(now->right!=NULL)
                  q.push(now->right);
              }
          }
          return dep;
    }
};

class Solution {
public:
    int dfs(int dep,TreeNode *root){
        //共四种情况
        if(root->left==NULL&&root->right==NULL)
          return dep;
        else{
            int dep1,dep2;
            //有一个子树为空
            if(root->left==NULL)
              return dfs(dep+1,root->right);
            else if(root->right==NULL)
              return dfs(dep+1,root->left);
            else{
                 int dep1,dep2;
                 dep1=dfs(dep+1,root->left);
                 dep2=dfs(dep+1,root->right);
                 return min(dep1,dep2);
            }       
        }
    }
    int minDepth(TreeNode* root) {
       if(root==NULL)
         return 0;
        return dfs(1,root);
    }
};