【代码随想录】刷题笔记Day21

前言

试试早上刷题会不会效率高一些，项目啊项目，耽误我刷题时间

100. 相同的树 - 力扣（LeetCode）

• 和对称树对比类似，写个compare函数，左左和右右比

• 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->left);   // 左子树：左、 右子树：左
          bool inside = compare(left->right, right->right);    // 左子树：右、 右子树：右
          bool isSame = outside && inside;                    // 左子树：中、 右子树：中 （逻辑处理）
          return isSame;
   
      }
      bool isSameTree(TreeNode* p, TreeNode* q) {
          if (p == NULL && q == NULL) return true;
          return compare(p, q);
      }
  };

572. 另一棵树的子树 - 力扣（LeetCode）

• 用了双重递归（一重判断两树相同，一层前序遍历root子节点）

• 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->left);   // 左子树：左、 右子树：左
          bool inside = compare(left->right, right->right);    // 左子树：右、 右子树：右
          bool isSame = outside && inside;                    // 左子树：中、 右子树：中 （逻辑处理）
          return isSame;
   
      }
      bool isSubtree(TreeNode* root, TreeNode* subRoot) {
          if(!root || !subRoot) return false;
          return compare(root, subRoot) || isSubtree(root->left, subRoot) || isSubtree(root->right, subRoot);
      }
  };

104. 二叉树的最大深度 - 力扣（LeetCode）

• 这道题之前可以用层序遍历迭代法每层depth++算得，这次用后序遍历递归法
• 最大深度实际上算的就是根节点的高度，因此用后序遍历（左右将高度传回父节点）
• 

• class solution {
  public:
      int getdepth(TreeNode* node) {
          if (node == NULL) return 0;
          int leftdepth = getdepth(node->left);       // 左
          int rightdepth = getdepth(node->right);     // 右
          int depth = 1 + max(leftdepth, rightdepth); // 中
          return depth;
      }
      int maxDepth(TreeNode* root) {
          return getdepth(root);
      }
  };

559. N 叉树的最大深度 - 力扣（LeetCode）

• 思路和上面一样的

• class solution {
  public:
      int maxDepth(Node* root) {
          if (root == 0) return 0;
          int depth = 0;
          for (int i = 0; i < root->children.size(); i++) {
              depth = max (depth, maxDepth(root->children[i]));
          }
          return depth + 1;
      }
  };

111. 二叉树的最小深度 - 力扣（LeetCode）

• 也是后序递归法，注意一边为空的陷阱
• 

• class Solution {
  public:
      int minDepth(TreeNode* root) {
          if(root == NULL) return 0;
          int leftDepth = minDepth(root->left);    // 左
          int rightDepth = minDepth(root->right);  // 右
                                                   // 中
          // 当一个左子树为空，右不为空，这时并不是最低点
          if(root->left == NULL && root->right != NULL){
              return rightDepth + 1;
          }
          // 当一个右子树为空，左不为空，这时并不是最低点
          if(root->left != NULL && root->right == NULL){
              return leftDepth + 1;
          }
          return 1 + min(leftDepth, rightDepth);
      }
  };

后言

先到这吧，开组会去咯