Leetcode__Maximum depth

104. Maximum Depth of Binary Tree

Total Accepted: 111336  Total Submissions: 238298  Difficulty: Easy

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.

Subscribe to see which companies asked this questio

这题困了我我挺长时间，没做过这种类型的，二叉树什么的不清楚是怎么回事。这两天在补~

运行成功的代码如下：

public class Solution {
    public int maxDepth(TreeNode root) {
        int depth = 0;
        if(root != null){
            int leftDepth = maxDepth(root.left);
            int rightDepth = maxDepth(root.right);
            depth ++;
            if(leftDepth < rightDepth){
                depth = depth + rightDepth;
            }else{
                depth = depth + leftDepth;
            }
        }
        return depth;
    }
}

预计还可以优化！

而后看到这下面这种解法，这种解法的巧妙之处在于把上述的意思，通过一句话来表示：

public class Solution {
    public int maxDepth(TreeNode root) {

        return (root == null)?0:Math.max(1+maxDepth(root.left),1+maxDepth(root.right));
    }//如果根节点为空，返回零，否则返回其左子树或是右子树的最高度。
}

另附我在一个地方找到的二叉树构建用例，用于做测试，经验证是可行的：

import java.util.LinkedList;
import java.util.List;



/**
 * 功能：把一个数组的值存入二叉树中，然后进行3种方式的遍历
 * 
 * 参考资料0:数据结构(C语言版)严蔚敏
 * 
 * 参考资料1：http://zhidao.baidu.com/question/81938912.html
 * 
 * 参考资料2：http://cslibrary.stanford.edu/110/BinaryTrees.html#java
 *
 * 参考资料3：http://ocaicai.iteye.com/blog/1047397
 * 
 * @author sunbinbin@zjut.edu.cn @date: 2016-01-08
 * 
 */
public class BinaryTree {

	private int[] array = { 1, 2, 3, 4, 5, 6, 7, 8, 9 ,10,11,12,12,12,12,14,15,16,14,15,16,17,18,19};
	private static List<Node> nodeList = null;

	/**
	 * 内部类：节点
	 * 
	 * @author ocaicai@yeah.net @date: 2016-1-7
	 * 
	 */
	private static class Node {
		Node leftChild;
		Node rightChild;
		int data;

		Node(int newData) {
			leftChild = null;
			rightChild = null;
			data = newData;
		}
	}

	public void createBinTree() {
		nodeList = new LinkedList<Node>();
		// 将一个数组的值依次转换为Node节点
		for (int nodeIndex = 0; nodeIndex < array.length; nodeIndex++) {
			nodeList.add(new Node(array[nodeIndex]));
		}
		// 对前lastParentIndex-1个父节点按照父节点与孩子节点的数字关系建立二叉树
		for (int parentIndex = 0; parentIndex < array.length / 2 - 1; parentIndex++) {
			// 左孩子
			nodeList.get(parentIndex).leftChild = nodeList
					.get(parentIndex * 2 + 1);
			// 右孩子
			nodeList.get(parentIndex).rightChild = nodeList
					.get(parentIndex * 2 + 2);
		}
		// 最后一个父节点:因为最后一个父节点可能没有右孩子，所以单独拿出来处理
		int lastParentIndex = array.length / 2 - 1;
		// 左孩子
		nodeList.get(lastParentIndex).leftChild = nodeList
				.get(lastParentIndex * 2 + 1);
		// 右孩子,如果数组的长度为奇数才建立右孩子
		if (array.length % 2 == 1) {
			nodeList.get(lastParentIndex).rightChild = nodeList
					.get(lastParentIndex * 2 + 2);
		}
	}

	/**
	 * 先序遍历
	 * 
	 * 这三种不同的遍历结构都是一样的，只是先后顺序不一样而已
	 * 
	 * @param node
	 *            遍历的节点
	 */
	public static void preOrderTraverse(Node node) {
		if (node == null)
			return;
		System.out.print(node.data + " ");
		preOrderTraverse(node.leftChild);
		preOrderTraverse(node.rightChild);
	}

	/**
	 * 中序遍历
	 * 
	 * 这三种不同的遍历结构都是一样的，只是先后顺序不一样而已
	 * 
	 * @param node
	 *            遍历的节点
	 */
	public static void inOrderTraverse(Node node) {
		if (node == null)
			return;
		inOrderTraverse(node.leftChild);
		System.out.print(node.data + " ");
		inOrderTraverse(node.rightChild);
	}

	/**
	 * 后序遍历
	 * 
	 * 这三种不同的遍历结构都是一样的，只是先后顺序不一样而已
	 * 
	 * @param node
	 *            遍历的节点
	 */
	public static void postOrderTraverse(Node node) {
		if (node == null)
			return;
		postOrderTraverse(node.leftChild);
		postOrderTraverse(node.rightChild);
		System.out.print(node.data + " ");
	}
	public int maxDepth(Node root) {
		int depth = 0;
		if(root != null){
			int leftDepth = maxDepth(root.leftChild);
			int rightDepth = maxDepth(root.rightChild);
			depth ++;
			if(leftDepth < rightDepth){
				depth = depth + rightDepth;
			}else{
				depth = depth + leftDepth;
			}
		}
		return depth; 
	} 
	public static void main(String[] args) {
		BinaryTree binTree = new BinaryTree();
		binTree.createBinTree();
		// nodeList中第0个索引处的值即为根节点
		Node root = nodeList.get(0);
		int a=binTree.maxDepth(root);
		System.out.println("a="+a);
		
		System.out.println("先序遍历：");
		preOrderTraverse(root);
		System.out.println();

		System.out.println("中序遍历：");
		inOrderTraverse(root);
		System.out.println();

		System.out.println("后序遍历：");
		postOrderTraverse(root);
	}

}

其中的几种遍历方法，我没删除！