二叉树定义及相关术语、节点数计算公式、代码实现(遍历，Java版)

二叉树

定义：二叉树是由n（n>=0）个节点组成的有限集，或者为空树（n=0），或者为由一个根节点和两个分别称为左子树和右子树的的互不相交的二叉树构成。

特点：（1）.每个节点最多能有两棵子树，即左子树和右子树。

             （2）.左子树和右子树有次序之分，如

                                
                                                                       

                                                        图1                                                                    图2

                                                                   图1和图2是不同的二叉树。

二叉排序树

定义 : 二叉排序树又叫二叉搜索树，它首先是一棵二叉树，而且满足下列条件:

           (1）若左子树不为空，则左子树所有节点的值均小于它的父节点的值。

           (2 ) 若右子树不为空，则右子树所有节点的值均大于它的父节点的值。

           (3 ) 左、右子树也分别为二叉排序树

术语：

（1）节点的度：一个节点含有的子树的个数。

（2）叶节点：度为零的节点。

（3）非叶节点：度不为零的节点。

（4）父节点：一个节点包含子节点，则该节点称为父节点。

（5）兄弟节点：具有相同父节点的节点。

（6）节点的层次：根节点的层次为1，根的子节点的层次为2，以此类推。

（7）树的高度或深度：树中节点的最大层次。

（8）节点的祖先：从根节点到该节点所经的分支上的所有节点。

（9）满二叉树：一个深度为k且节点数为2^k-1的二叉树。

（10）完全二叉树：完全二叉树是由满二叉树而引出来的。对于深度为K的，有n个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的节点一一对应 时称之为完全二叉树。

计算公式:

 (1) 在非空二叉树中，第i层的结点总数不超过2^(i-1),i>=1； 

 (2) 深度为h的二叉树最多有2^h-1个结点(h>=1)，最少有h个结点； 
 (3) 对于任意一棵二叉树，如果其叶结点数为N0，而度数为2的结点总数为N2，则N0=N2+1； 
 (4) 具有n个结点的完全二叉树的深度为K =[log2n」+1(取下整数) 
 (5)有N个结点的完全二叉树各结点如果用顺序方式存储，则结点之间有如下关系： 若I为结点编号则 如果I>1，则其父结点的编号为I/2； 
如果2*I<=N，则其左儿子（即左子树的根结点）的编号为2*I；若2*I>N，则无左儿子； 如果2*I+1<=N，则其右儿子的结点编号为2*I+1；若2*I+1>N，则无右儿子。 (6)给定N个节点，能构成h(N)种不同的二叉树。h(N)为卡特兰数的第N项。h(n)=C(2*n，n)/(n+1)。 

(以下代码为Java版)

二叉树节点定义(BinaryTreeNode)

class BinaryTreeNode {
	int value;
	BinaryTreeNode t_left; // 左子树
	BinaryTreeNode t_right;// 右子树

	public BinaryTreeNode(int value) {
		this.value = value;
		this.t_left = null;
		this.t_right = null;

	}
}

二叉树的遍历(前中后序，深度，层次）

	/*
	 * 前序遍历：首先访问根节点，然后遍历左子树，最后遍历右子树
	 */
	public static void preOrder(BinaryTreeNode node) {
		if (node != null) {
			System.out.println(node.value);
			preOrder(node.left);
			preOrder(node.right);
		}
	}

	/*
	 * 中序遍历：首先遍历左子树，然后访问根节点，最后遍历右子树
	 */
	public static void inOrder(BinaryTreeNode node) {
		if (node != null) {
			inOrder(node.left);
			System.out.println(node.value);
			inOrder(node.right);
		}
	}

	/*
	 * 后序遍历：首先遍历左子树，然后遍历右子树，最后访问根节点
	 */
	public static void postOrder(BinaryTreeNode node) {
		if (node != null) {
			postOrder(node.left);
			postOrder(node.right);
			System.out.println(node.value);
		}
	}

	/*
	 * 层次遍历
	 */
	public static void levelOrder(BinaryTreeNode node) {
		if (node != null) {
			Queue<BinaryTreeNode> queue = new LinkedList<BinaryTreeNode>();
			queue.add(node);
			while (!queue.isEmpty()) {
				BinaryTreeNode newNode = queue.poll();
				System.out.println(newNode.value);
				if (newNode.left != null)
					queue.add(newNode.left);
				if (newNode.right != null)
					queue.add(newNode.right);
			}
		}
	}

	/*
	 * 二叉树深度：递归
	 */
	public static int getMathDepth(BinaryTreeNode node) {
		if (node == null)
			return 0;
		int left = getMathDepth(node.left);
		int right = getMathDepth(node.right);
		return 1 + Math.max(left, right);
	}