二叉树建立、递归、非递归遍历

• 结点的度：一个结点的子树的个数记为该结点的度．
• 树的度：所有节点中度数最大的结节的度数，叶子节点的度为零。
• 树的高度：一棵树的最大层次数记为树的高度(或深度)。
• 有序(无序)树：若将树中结点的各子树看成是从左到右具有次序的，即不能交换，则称该树为有序树。否则称为无序树。
• 二叉树第i层（i≥1）上至多有2^(i-1)个节点。
• 深度为k的二叉树至多有2^k-1个节点（k≥1）。
• 对任何一棵二叉，若叶子节点数为n0，度为2的节点数为n2，则n0=n2+1。
• 具有n个节点的完全二叉树的深度为 (㏒2^n)(向下取整)+1。
• 对一棵有n个节点的完全二叉树的节点按层次从上到下，自左至右进行编号，则对任一节点i(1≤i≤n)有：若 i=1，则节点i是二叉树的根，无双亲；若 i>1，则其双亲为 i/2(向下取整)。若2i>n，则节点i没有孩子节点，否则其左孩子为2i。若2i+1>n，则节点i没有右孩子，否则其右孩子为2i+1。
• 若深度为k的二叉树有2^k-1个节点，则称其为满二叉树。满二叉树是一棵完全二叉树。

                             

• 对于完全二叉树中，度为1的节点个数只可能为1个或0个。
• 对于二叉树，如果叶子节点数为n0，度为1的节点数为n1，度为2的节点数为n2，则节点总数n     = n0 + n1 + n2。
• 对于任意树，总节点数     = 每个节点度数和 + 1
• 二叉树的高度等于根与最远叶节点（具有最多祖先的节点）之间分支数目。空树的高度是-1。只有单个元素的二叉树，其高度为0。

 

package com.ccl.tree;

import com.ccl.tree.BiTreeOrder.DepthOrderIterator;
import com.ccl.tree.BiTreeOrder.LevelOrderIterator;
import com.ccl.tree.BiTreeOrder.Visitor;

public class BiTree {

	Node root = null;
	int size = 0;

	public BiTree() {

	}

	class Node {
		Node left = null;
		Node right = null;
		int number = 0;

		public Node(int number) {
			this.number = number;
		}

		public String toString() {
			return "node:" + number;
		}
	}

	public void createBiTree(int elements[]) {

		root = createBiTree(elements, 0, elements.length);
	}

	public Node createBiTree(int[] elements, int index, int length) {

		if (elements[index] != 0) {
			size++;
			Node rootNode = new Node(elements[index]);// 根节点
			// 如果有左子树则创建左子树
			if ((index + 1) * 2 <= length) {
				rootNode.left = (Node) createBiTree(elements,
						(index + 1) * 2 - 1, length);
				// 如果还可以创建右子树，则创建
				if ((index + 1) * 2 + 1 <= length) {
					rootNode.right = (Node) createBiTree(elements,
							(index + 1) * 2, length);
				}
			}
			return (Node) rootNode;
		}

		return null;
	}

	public static void main(String args[]) {

		BiTree tree = new BiTree();
		int[] elements = new int[] { 1, 2, 3, 4, 0, 0, 5, 0, 6, 0, 0, 0, 0, 7,
				8 };

		tree.createBiTree(elements);

		System.out.println(tree.size);

		BiTreeOrder treeOrder = new BiTreeOrder();
		treeOrder.preOrder(new Visitor() {
		}, tree.root);

		// 深度优先==前序遍历
		System.out.println("深度优先：");
		DepthOrderIterator depthOrder = new DepthOrderIterator(tree.root);
		while (depthOrder.hasNext()) {
			System.out.println(depthOrder.next());
		}
		// ==层序遍历
		System.out.println("广度优先:");
		LevelOrderIterator levelOrder = new LevelOrderIterator(tree.root);
		while (levelOrder.hasNext()) {
			System.out.println(levelOrder.next());
		}

	}
}

 

package com.ccl.tree;

import java.util.Iterator;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Stack;

public class BiTreeOrder extends BiTree {

	static abstract class Visitor {
		void visit(Object o) {
			System.out.println(o);
		}
	}

	public void preOrder(Visitor v, Node root) {
		if (root != null) {
			v.visit(root);
			preOrder(v, root.left);
			preOrder(v, root.right);
		}
	}

	static class DepthOrderIterator implements Iterator<Object> {

		private Stack<Object> stack = new Stack<Object>();

		public DepthOrderIterator(Node o) {
			stack.push(o);
		}

		@Override
		public boolean hasNext() {
			if (!stack.isEmpty())
				return true;
			return false;
		}

		@Override
		public Object next() {
			if (hasNext()) {
				Node node = (Node) stack.pop();
				if (node.right != null) {
					stack.push(node.right);
				}
				if (node.left != null) {
					stack.push(node.left);
				}
				return node;
			} else {
				return null;
			}

		}

		@Override
		public void remove() {
		}

	}

	static class LevelOrderIterator implements Iterator<Object> {

		private LinkedList<Object> queue = new LinkedList<Object>();

		public LevelOrderIterator(Node o) {
			queue.addLast(o);
		}

		@Override
		public boolean hasNext() {
			if (!queue.isEmpty())
				return true;
			return false;
		}

		@Override
		public Object next() {
			if (hasNext()) {
				Node node = (Node) queue.removeFirst();
				if (node.left != null)
					queue.addLast(node.left);
				if (node.right != null)
					queue.addLast(node.right);
				return node;
			} else {
				return null;
			}
		}

		@Override
		public void remove() {

		}

	}

}