Java实现二叉树创建及便遍历

/**
 * 二叉树是数据元素间具有层次关系的非线性结构，而且二叉树每个结点的两个子树有
 * 左右之分。
 * 对于给定的一棵二叉树，其先序/中序/后序遍历是唯一确定的，但给定一种遍历，无法
 * 确定一棵二叉树。先序/后序反应父结点与孩子结点层次关系，中序反应兄弟结点间左右次序
 * */
public class BinaryTree {//二叉树是有序树，每个结点的两棵子树有左、右之分
	TreeNode root;//根结点
	private int size = 0;//树的大小
	public BinaryTree() {//无参构造
	
	}
	/*有序树求得最大值-最小值*/
	public int getMax() {
		TreeNode node = root;
		while ( node.rightChild!=null) {
			node = node.rightChild;
		}
		return node.value;
	}
	public int getMin() {
		TreeNode node = root;
		while ( node.leftChild!=null) {
			node = node.leftChild;
		}
		return node.value;
	}
	/*得到二叉树大小*/
	public int getSize() {
		return this.size;
	}
	/*生成二叉树*/
	public void createBinaryTree( int [] data) {//传入无序数组构造二叉树
		for ( int i: data) {
			insertTree(i);
		}
	}
	public void insertTree( int data ) {//插入结点
		if( root == null ) {//如果没有根结点首先插入根结点
			root = new TreeNode(data);
		} else {//判断传入的值和左右子树关系
			TreeNode cur = root;
			TreeNode parent;
			while ( true ) {//while(true)这个循环来找到目标插入位置
				parent = cur;
				if ( data < cur.value ) {
					cur = parent.leftChild;//一直到左结点为叶子结点
					if( cur == null ) {
						parent.leftChild = new TreeNode(data);
						break;
					}
				} else {
					cur = parent.rightChild;//一直到左结点为叶子结点
					if( cur == null ) {
						parent.rightChild = new TreeNode(data);
						break;
					}
				}
			}			
		}
		size++;
	}
	/*先序递归遍历*/
	public void preOrder(TreeNode node ) {
		if( node == null ) {//终止递归条件
			return;
		}
		System.out.print( node.value + "--");
		preOrder(node.leftChild );
		preOrder(node.rightChild);
	}
	/*中序递归遍历*/
	public void midOrder(TreeNode node ) {
		if( node == null ) {//终止递归条件
			return;
		}		
		midOrder(node.leftChild );
		System.out.print( node.value + "--");
		midOrder(node.rightChild);
	}
	/*后序递归遍历*/
	public void postOrder(TreeNode node ) {
		if( node == null ) {//终止递归条件
			return;
		}		
		postOrder(node.leftChild );
		postOrder(node.rightChild);
		System.out.print( node.value + "--");
	}
	/*查找*/
	public boolean search( int data ) {
		boolean result = false;
		TreeNode node = root;
		while( true ) {
			if ( data == node.value) {
				result = true;
				break;
			} else if ( data < node.value ) {
				node = node.leftChild;
				if( node == null ) {
					break;
				}
			} else {
				node = node.rightChild;
				if( node == null ) {
					break;
				}
			}			
		}
		return result;
	}
}
class TreeNode{
	TreeNode leftChild;
	TreeNode rightChild;
	int value;
	public TreeNode(int data) {//构造有值结点
		this.value = data;
		leftChild = null;
		rightChild = null;
	}
}

测试结果：

<pre name="code" class="java">public class BinaryTreeTest {
	public static void main(String[] args) {
		BinaryTree tree = new BinaryTree();
		int []data = {2,4,6,1,3,9,11,8,7};
		tree.createBinaryTree(data);
		System.out.println("先序遍历：");
		tree.preOrder(tree.root);
		System.out.println();	
		System.out.println("中序遍历：");
		tree.midOrder(tree.root);
		System.out.println();	
		System.out.println("后序遍历：");
		tree.postOrder(tree.root);
		System.out.println();
		System.out.println("查找结果：");		
		System.out.println(tree.search(16)==false?"不存在":"存在");
	}
}

控制台输出：

先序遍历：
2--1--4--3--6--9--8--7--11--
中序遍历：
1--2--3--4--6--7--8--9--11--
后序遍历：
1--3--7--8--11--9--6--4--2--
查找结果：
不存在