二叉树的最大深度

原题

　　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.

题目大意

　　给定一棵两叉树，求它的最大深度。

解题思路

　　递归求解，递归公式
　　f(n) = 0; n=null,
　　f(n) = 1+ max(f(n左)， f(n右))

代码实现

树结点类

public class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;

    TreeNode(int x) {
        val = x;
    }
}

 

算法实现类

public class Solution {

    public int maxDepth(TreeNode root) {
        if (root == null) {
            return 0;
        } else if (root.left == null && root.right == null) {
            return 1;
        } else {
            int left = maxDepth(root.left);
            int right = maxDepth(root.right);
            return 1 + (left > right ? left : right);
        }
    }
}

给定一个二叉树，找出其最大深度。
二叉树的深度为根节点到最远叶子节点的距离。
样例:
给出一棵以下的二叉树:

1
/ \
2 3
/ \
4 5
这个二叉树的最大深度为3.

题目来源

/**
 * Definition of TreeNode:
 * public class TreeNode {
 *     public int val;
 *     public TreeNode left, right;
 *     public TreeNode(int val) {
 *         this.val = val;
 *         this.left = this.right = null;
 *     }
 * }
 */
public class Solution {
    /**
     * @param root: The root of binary tree.
     * @return: An integer.
     */
     static int count = 0;
    public int maxDepth(TreeNode root) {
        // write your code here
        TreeNode last;
        TreeNode nlast;
        //定义一个用来存储结点的队列
        LinkedList<TreeNode> link = new LinkedList<TreeNode>();
        last = root;
        nlast = null;
        link.add(last);
        if(root == null) 
            return 0;
        while(!link.isEmpty()){
            TreeNode tn = link.removeFirst();//tn为根结点
            if(tn.left != null ){
                link.add(tn.left);
                nlast = tn.left;
            }
            if(tn.right != null ){
                link.add(tn.right);
                nlast = tn.right;
            }
            if(tn == last){
                last = nlast;
                count++;
            }
        }
        return count;
    }
}

 

总结：求二叉树的最大深度，其实就是求二叉树的层数（也是按层次打印二叉树的时候换行的次数），因此这个题咱们只要稍加修改一下按照层次打印二叉树的代码就可达到目的。

求二叉树的深度和宽度[Java]

这个是常见的对二叉树的操做。总结一下：

设节点的数据结构，以下：

1 class TreeNode {
2     char val;
3     TreeNode left = null;
4     TreeNode right = null;
5 
6     TreeNode(char _val) {
7         this.val = _val;
8     }
9 }

 1.二叉树深度

　　这个能够使用递归，分别求出左子树的深度、右子树的深度，两个深度的较大值+1便可。

 1     // 获取最大深度
 2     public static int getMaxDepth(TreeNode root) {
 3         if (root == null)
 4             return 0;
 5         else {
 6             int left = getMaxDepth(root.left);
 7             int right = getMaxDepth(root.right);
 8             return 1 + Math.max(left, right);
 9         }
10     }

2.二叉树宽度

　　使用队列，层次遍历二叉树。在上一层遍历完成后，下一层的全部节点已经放到队列中，此时队列中的元素个数就是下一层的宽度。以此类推，依次遍历下一层便可求出二叉树的最大宽度。

 1 // 获取最大宽度
 2     public static int getMaxWidth(TreeNode root) {
 3         if (root == null)
 4             return 0;
 5 
 6         Queue<TreeNode> queue = new ArrayDeque<TreeNode>();
 7         int maxWitdth = 1; // 最大宽度
 8         queue.add(root); // 入队
 9 
10         while (true) {
11             int len = queue.size(); // 当前层的节点个数
12             if (len == 0)
13                 break;
14             while (len > 0) {// 若是当前层，还有节点
15                 TreeNode t = queue.poll();
16                 len--;
17                 if (t.left != null)
18                     queue.add(t.left); // 下一层节点入队
19                 if (t.right != null)
20                     queue.add(t.right);// 下一层节点入队
21             }
22             maxWitdth = Math.max(maxWitdth, queue.size());
23         }
24         return maxWitdth;
25