LeetCode:Minimum Depth of Binary Tree,Maximum Depth of Binary Tree

LeetCode:Minimum Depth of Binary Tree

Given a binary tree, find its minimum depth.

The minimum depth is the number of nodes along the shortest path from the root node down to the nearest leaf node.

算法1：dfs递归的求解

 class Solution {
 public:
     int minDepth(TreeNode *root) {
         // IMPORTANT: Please reset any member data you declared, as
         // the same Solution instance will be reused for each test case.
         if(root == NULL)return ;
         int res = INT_MAX;
         dfs(root, , res);
         return res;
     }
     void dfs(TreeNode *root, int depth, int &res)
     {
         if(root->left == NULL && root->right == NULL && res > depth)
             {res = depth; return;}
         if(root->left)
             dfs(root->left, depth+, res);
         if(root->right)
             dfs(root->right, depth+, res);
     }
 };

还有一种更直观的递归解法，分别求左右子树的最小深度，然后返回左右子树的最小深度中较小者+1

 class Solution {
 public:
     int minDepth(TreeNode *root) {
         if(root == NULL)return ;
         int minleft = minDepth(root->left);
         int minright = minDepth(root->right);
         if(minleft == )
             return minright + ;
         else if(minright == )
             return minleft + ;
         else return min(minleft, minright) + ;
     }
 };

算法2：层序遍历二叉树，找到最先遍历到的叶子的层数就是树的最小高度

 /**
  * Definition for binary tree
  * struct TreeNode {
  * int val;
  * TreeNode *left;
  * TreeNode *right;
  * TreeNode(int x) : val(x), left(NULL), right(NULL) {}
  * };
  */
 class Solution {
 public:
     int minDepth(TreeNode *root) {
         // IMPORTANT: Please reset any member data you declared, as
         // the same Solution instance will be reused for each test case.
          //层序遍历，碰到第一个叶子节点就停止,NULL作为每一层节点的分割标志
         if(root == NULL)return ;
         int res = ;
         queue<TreeNode*> Q;
         Q.push(root);
         Q.push(NULL);
         while(Q.empty() == false)
         {
             TreeNode *p = Q.front();
             Q.pop();
             if(p != NULL)
             {
                 if(p->left)Q.push(p->left);
                 if(p->right)Q.push(p->right);
                 if(p->left == NULL && p->right == NULL)
                 {
                     res++;
                     break;
                 }
             }
             else
             {
                 res++;
                 if(Q.empty() == false)Q.push(NULL);
             }
         }
         return res;
     }
 };

本文地址

---

LeetCode:Maximum Depth of Binary Tree

Given a binary tree, find its maximum depth.

The maximum depth is the number of nodes along the longest path from the root node down to the farthest leaf node.

算法1：dfs递归求解

 /**
  * Definition for binary tree
  * struct TreeNode {
  * int val;
  * TreeNode *left;
  * TreeNode *right;
  * TreeNode(int x) : val(x), left(NULL), right(NULL) {}
  * };
  */
 class Solution {
 public:
     int maxDepth(TreeNode *root) {
         // IMPORTANT: Please reset any member data you declared, as
         // the same Solution instance will be reused for each test case.
         if(root == NULL)return ;
         int res = INT_MIN;
         dfs(root, , res);
         return res;
     }
     void dfs(TreeNode *root, int depth, int &res)
     {
         if(root->left == NULL && root->right == NULL && res < depth)
             {res = depth; return;}
         if(root->left)
             dfs(root->left, depth+, res);
         if(root->right)
             dfs(root->right, depth+, res);
     }
 };

同上一题

 class Solution {
 public:
     int maxDepth(TreeNode *root) {
         if(root == NULL)return ;
         int maxleft = maxDepth(root->left);
         int maxright = maxDepth(root->right);
         if(maxleft == )
             return maxright + ;
         else if(maxright == )
             return maxleft + ;
         else return max(maxleft, maxright) + ;
     }
 };

算法2：层序遍历，树的总层数就是树的最大高度

 /**
  * Definition for binary tree
  * struct TreeNode {
  * int val;
  * TreeNode *left;
  * TreeNode *right;
  * TreeNode(int x) : val(x), left(NULL), right(NULL) {}
  * };
  */
 class Solution {
 public:
     int maxDepth(TreeNode *root) {
         // IMPORTANT: Please reset any member data you declared, as
         // the same Solution instance will be reused for each test case.
         //层序遍历计算树的层数即可,NULL作为每一层节点的分割标志
         if(root == NULL)return ;
         int res = ;
         queue<TreeNode*> Q;
         Q.push(root);
         Q.push(NULL);
         while(Q.empty() == false)
         {
             TreeNode *p = Q.front();
             Q.pop();
             if(p != NULL)
             {
                 if(p->left)Q.push(p->left);
                 if(p->right)Q.push(p->right);
             }
             else
             {
                 res++;
                 if(Q.empty() == false)Q.push(NULL);
             }
         }
         return res;
     }
 };

【版权声明】转载请注明出处：http://www.cnblogs.com/TenosDoIt/p/3440059.html