LeetCode Minimum Depth of Binary Tree 找最小深度（返回最小深度）

题意：找到离根结点最近的叶子结点的那一层（设同一层上的结点与根结点的距离相等），返回它所在的层数。

方法有：

1、递归深度搜索

2、层次搜索

方法一：递归（无优化）

 1 /**
 2  * Definition for binary tree
 3  * struct TreeNode {
 4  *     int val;
 5  *     TreeNode *left;
 6  *     TreeNode *right;
 7  *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 8  * };
 9  */
10 class Solution {
11 public:
12 int minDepth(TreeNode *root) {
13     if( root==0 )    //针对树根
14         return 0;
15     if(root->left==0&&root->right==0)    //是叶子，立即返回1
16         return 1;
17     int zuo,you,com;
18     if(root->left!=0&&root->right!=0){    //左右孩子均存在
19         zuo=minDepth(root->left);
20         you=minDepth(root->right);
21         return zuo<=you?++zuo:++you;
22     }
23     else{
24         if(root->left!=0&&root->right==0){    //只有左孩子，那么只需要沿着左孩子方向搜索
25             com=minDepth(root->left);
26         }
27         else{    //即(root->left==0&&root->right!=0)    只有右孩子，那么只需要沿着左孩子方向搜索
28             com=minDepth(root->right);
29         }
30         return ++com;
31     }
32 }
33 };

思路：递归寻找叶子结点。

注意：如果一个结点只有一个孩子，不能调用两次函数来分别搜索左右子树，不然空的一边会返回0，那么结果就错了。

方法二：递归（稍微优化）

 1 /**
 2  * Definition for binary tree
 3  * struct TreeNode {
 4  *     int val;
 5  *     TreeNode *left;
 6  *     TreeNode *right;
 7  *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 8  * };
 9  */
10 class Solution {
11 public:
12 int mini(TreeNode *root) {
13     if( root->left==0 && root->right==0 )    //叶子结点，返回
14         return 1;
15     int zuo,you,com;
16     if(root->left!=0 && root->right!=0 ){    //左右孩子均存在
17         if( root->left->left==0 && root->left->right==0 ){    //左孩子是叶子，右孩子不一定是叶子，无必要再搜索右孩子了
18             zuo=mini( root->left );
19             return ++zuo;
20         }
21         else if( root->right->left==0 && root->right->right==0 ){    //右孩子是叶子，左孩子不一定是叶子，无必要再搜索左孩子了
22             you=mini( root->right );
23             return ++you;
24         }
25         else{        //左右孩子均不是叶子，都需要继续向下搜索
26             zuo=mini( root->left );
27             you=mini( root->right );
28             return zuo<=you?++zuo:++you;
29         }
30     }
31     else{    //只有一个孩子
32         if(root->left!=0)        //只有左孩子
33             com=mini( root->left );
34         else                    //只有右孩子
35             com=mini( root->right );
36         return ++com;
37     }
38 }
39 int minDepth(TreeNode *root) {
40     if( root==0 )    //只针对空树
41         return 0;
42     return mini(root);
43 }
44 };

思想是：若一个结点有两个孩子，而其中一个孩子是叶子，而另一个不是，那么就无需再搜索那个“不是叶子”的孩子了，因为它算出来的深度肯定比那个叶子的长。（具体自己画图领会）

吐槽：只是优化这么一点就需要考虑挺多东西。怪自己整体把握能力偏弱，总是需要先把代码打出来，修改，再修改才能解决。若能做到还没打代码之前就大概掌控整体结构，打出来就快多了。

方法三：层次遍历（暂时没空写）