(学习java)二叉树的链式实现以及三种遍历方式

//二叉树的链表结构
public class BinTree<T> {

	// 结点类
	class TreeNode {
		// 结点存储的数据
		Object data;
		// 结点左孩子
		TreeNode lchild;
		// 结点右孩子
		TreeNode rchild;

		public TreeNode() {

		}

		public TreeNode(Object data) {
			super();
			this.data = data;
		}
	}

	// 定义根结点
	private TreeNode root;

	public BinTree() {
	}

	public BinTree(T data) {
		this.root = new TreeNode(data);
	}

	// 添加结点 (isLeft是否添加在parent的左结点)
	public TreeNode addNode(TreeNode parent, T data, boolean isLeft) {

		if (parent == null) {
			throw new RuntimeException("父结点为空,无法添加子结点");
		} else if (isLeft && (parent.lchild != null)) {
			throw new RuntimeException("左孩子结点不为空,无法添加结点");
		} else if ((!isLeft) && (parent.rchild != null)) {
			throw new RuntimeException("右孩子结点不为空,无法添加结点");
		}
		TreeNode node = new TreeNode(data);
		if (isLeft) {
			parent.lchild = node;
		} else {
			parent.rchild = node;
		}

		return node;
	}

	// 返回双亲结点
	public TreeNode parent(TreeNode node) {
		// 根为空,或者结点就是根,返回空,否则返回该结点的双亲结点
		return (root == null || root == node) ? null : parent(root, node);
	}

	public TreeNode parent(TreeNode subTree, TreeNode node) {
		if (subTree == null) {
			return null;
		}

		// 如果subTree的左或者右孩子是node,则返回subTree
		if (subTree.lchild == node || subTree.rchild == node) {
			return subTree;
		}
		// 如果不是,这依次遍历其左右子树,最终找到其双亲结点
		TreeNode p;
		if ((p = parent(subTree.lchild, node)) != null) {
			return p;
		} else {
			return parent(subTree.rchild, node);
		}
	}

	// 判断二叉树是否为空
	public boolean isEmpty() {
		if (root.data == null) {
			return true;
		} else {
			return false;
		}
	}

	// 获取根结点
	public TreeNode getRoot() {
		if (isEmpty()) {
			System.out.println("二叉树为空");
			return null;
		} else {
			return root;
		}
	}

	// 获取结点的左子树
	public TreeNode getLeft(TreeNode parent) {
		if (parent == null) {
			throw new RuntimeException("该结点为空,无法获取左子树");
		} else {
			return parent.lchild;
		}
	}

	// 获取结点的右子树
	public TreeNode getRight(TreeNode parent) {
		if (parent == null) {
			throw new RuntimeException("该结点为空,无法获取右子树");
		} else {
			return parent.rchild;
		}
	}

	private int getDeep(TreeNode node) {
		if (node == null) {
			return 0;
		} else {
			// 叶子结点,返回第一层
			if ((node.lchild == null) && (node.rchild) == null) {
				return 1;
			} else {
				// 求出左结点为叶子的结点时的最大深度
				int left = getDeep(node.lchild);
				// 求出右结点为叶子的结点时的最大深度
				int right = getDeep(node.rchild);
				// 取最大值为该结点的深度
				int max = (left > right) ? left : right;
				return max + 1;
			}
		}
	}

	// 求树的深度
	public int getTreeDeep() {
		return getDeep(root);
	}

	// 获取结点的个数
	public int size() {
		return size(root);
	}

	private int size(TreeNode node) {
		if (node == null) {
			return 0;
		} else {
			// 结点个数为,本身+左孩子结点数+右孩子结点数
			return 1 + size(node.lchild) + size(node.rchild);
		}
	}

	private void visit(TreeNode node) {
		System.out.print(node.data + " ");
	}

	// 遍历结点(前序遍历)
	public void preOrder(TreeNode node) {
		if (node != null) {
			visit(node);
			preOrder(node.lchild);
			preOrder(node.rchild);
		}
	}

	// 遍历结点(中序遍历)
	public void inOrder(TreeNode node) {
		if (node != null) {
			inOrder(node.lchild);
			visit(node);
			inOrder(node.rchild);
		}
	}

	// 遍历结点(后序遍历)
	public void postOrder(TreeNode node) {
		if (node != null) {
			postOrder(node.lchild);
			postOrder(node.rchild);
			visit(node);
		}
	}

}

测试类

import mytree.BinTree.TreeNode;
/*
 * 二叉树
 * 			A
 *     B         C 
 * D       E  F
 * */

public class BinTreeTest {
	public static void main(String[] args) {
		//定义一颗二叉树,根节点是A
		BinTree<Character> bt = new BinTree<Character>('A');

		TreeNode node1 = bt.addNode(bt.getRoot(), 'B', true);
		
		TreeNode node2 = bt.addNode(bt.getRoot(), 'C', false);
		
		TreeNode node3 = bt.addNode(node1, 'D', true);
		
		TreeNode node4 = bt.addNode(node1, 'E', false);
		
		TreeNode node5 = bt.addNode(node2, 'F', true);
		
		System.out.println("树的深度" + bt.getTreeDeep());
		System.out.println("树的总结点" + bt.size());
		
		System.out.print("前序遍历: ");
		
		bt.preOrder(bt.getRoot());
		
		System.out.println();
		
		System.out.print("中序遍历: ");		
		
		bt.inOrder(bt.getRoot());
		
		System.out.println();
		
		System.out.print("后序遍历: ");
		
		bt.postOrder(bt.getRoot());
	}
}