day 16：第六章 二叉树part03

总结

自我感觉层序遍历用起来更简单，递归法更难理解。
递归法最好写出三要素再写代码

● 104.二叉树的最大深度 559.n叉树的最大深度
● 111.二叉树的最小深度
● 222.完全二叉树的节点个数

● 104.二叉树的最大深度 559.n叉树的最大深度

/*104. 二叉树的最大深度
    简单
给定一个二叉树 root ，返回其最大深度。
二叉树的 最大深度 是指从根节点到最远叶子节点的最长路径上的节点数。*/
class Solution_104 {
 public:
  struct TreeNode {
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode() : val(0), left(nullptr), right(nullptr) {}
    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
    TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
  };
/*
 * 迭代方法，类似层序遍历
 * 还实现了递归方法
 */
  int maxDepth(TreeNode *root) {
      int res = 0;
      if (!root)
          return res;
      queue<TreeNode *> record;
      record.push(root);
      while (!record.empty()) {
          res += 1;
          int size = record.size();
          while (size--) {
              TreeNode *node = record.front();
              record.pop();
              if (node->left)
                  record.push(node->left);
              if (node->right)
                  record.push(node->right);
          }
      }
      return res;
  }

  /*
   * 递归方法
   *
   */
  int order(TreeNode *node) {
      if(!node)
          return 0;
      int depth_1 = order(node->left);
      int depth_2 = order(node->right);
      return depth_1 > depth_2 ? (depth_1 + 1) : (depth_2 + 1);
  }
  int maxDepth_di_gui(TreeNode *root) {
      return order(root);
  }
};

● 111.二叉树的最小深度

/*111. 二叉树的最小深度
    简单
给定一个二叉树，找出其最小深度。
最小深度是从根节点到最近叶子节点的最短路径上的节点数量。
说明：叶子节点是指没有子节点的节点。*/
class Solution_111 {
 public:
  struct TreeNode{
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode() : val(0), left(nullptr), right(nullptr) {}
    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
    TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
  };

  int minDepth(TreeNode* root) {
      int res = 0;
      if(!root)
          return res;
      queue<TreeNode*> record;
      record.push(root);
      while (!record.empty()){
          res += 1;
          int size = record.size();
          while (size--) {
              TreeNode *node = record.front();
              record.pop();
              if (node->left)
                  record.push(node->left);
              if (node->right)
                  record.push(node->right);
              if(!node->left && !node->right)
                  return res;
          }
      }
      return res;
  }

  /*
   * 返回参数为左右子树最小深度，输入参数为节点
终止条件为节点为空
单层递归逻辑为单个节点为空时最小深度为1+另一节点深度
否则为1+两者最小节点深度
   */
  int get_depth(TreeNode* node){
      if(!node)
          return 0;
      int left_depth = get_depth(node->left);
      int right_depth = get_depth(node->right);
      if(!node->left && node->right)
          return 1 + right_depth;
      if(!node->right && node->left)
          return 1 + left_depth;
      return 1 + min(left_depth, right_depth);
  }
  int minDepth_di_gui(TreeNode* root) {
      return get_depth(root);
  }
};

● 222.完全二叉树的节点个数

/*222. 完全二叉树的节点个数
    简单
给你一棵 完全二叉树 的根节点 root ，求出该树的节点个数。
完全二叉树 的定义如下：在完全二叉树中，除了最底层节点可能没填满外，其余每层节点数都达到最大值，
 并且最下面一层的节点都集中在该层最左边的若干位置。若最底层为第 h 层，则该层包含 1~ 2h 个节点。*/
class Solution_222 {
 public:
  struct TreeNode{
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode() : val(0), left(nullptr), right(nullptr) {}
    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
    TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
  };
  /*
   * 迭代法，102 层序遍历
   * 递归法
   */
  int countNodes(TreeNode* root) {
      int res = 0;
      if(!root)
          return res;
      queue<TreeNode*> record;
      record.push(root);
      while (!record.empty()){
          int size = record.size();
          res += size;
          while (size--) {
              TreeNode *node = record.front();
              record.pop();
              if (node->left)
                  record.push(node->left);
              if (node->right)
                  record.push(node->right);
          }
      }
      return res;
  }
  /*
   * 递归法
   */
  int get_node_num(TreeNode* node){
      if(!node)
          return 0;
      int left = get_node_num(node->left);
      int right = get_node_num(node->right);
      return 1 + left + right;
  }
  
  int countNodes_di_gui(TreeNode* root) {
      return get_node_num(root);
  }
};