实现二叉树（包括前序、中序、后序遍历算法）

以前没有记笔记的习惯，结果发现曾经实现过的东西居然都忘了，现在又需要花时间去看，去写，虽然又有所收获，但是毕竟在走重复的路。

从今天起，开始打路标，为了以后少走回头路：）

还请高手多指点，不胜感激！

用Java语言实现二叉树：

1、首先定义一个二叉树节点类：实现

1）向某个节点下面添加节点方法；

2）从某个节点前序遍历所有树节点；

3）从某个节点中序遍历所有树节点；

4）从某个节点后序遍历所有树节点；

/**
 * 二叉树节点
 * 
 * @author dobuy
 * 
 */
public class TreeNode
{
	/**
	 * 左树节点
	 */
	private TreeNode leftTreeNode;

	/**
	 * 右树节点
	 */
	private TreeNode rightTreeNode;

	/**
	 * 当前树节点的数值
	 */
	private int data;

	public TreeNode(int data)
	{
		setData(data);
	}

	/**
	 * 添加树节点
	 * 
	 * @param treeNode
	 */
	public void addTreeNode(TreeNode treeNode)
	{
		// 插入节点比当前节点小，添加到左节点上
		if (getData() > treeNode.getData())
		{
			// 当前节点存在左节点，添加至左树节点上
			if (null != getLeftTreeNode())
			{
				getLeftTreeNode().addTreeNode(treeNode);
			}
			// 不存在左树节点，插入节点直接设成当前的左树节点
			else
			{
				setLeftTreeNode(treeNode);
			}
		}
		// 否则添加到右树节点上
		else
		{
			// 当前节点存在右树节点，添加至右树节点上
			if (null != getRightTreeNode())
			{
				getRightTreeNode().addTreeNode(treeNode);
			}
			// 不存在右树节点，插入节点直接设成当前的右树节点
			else
			{
				setRightTreeNode(treeNode);
			}
		}

	}

	/**
	 * 前序遍历树节点
	 * 
	 */
	public void preOrder()
	{
		// 打印当前树节点数据
		System.out.print(getData() + "\t");

		// 存在左树节点，前序遍历左树节点
		if (null != getLeftTreeNode())
		{
			getLeftTreeNode().preOrder();
		}

		// 存在右树节点，前序遍历右树节点
		if (null != getRightTreeNode())
		{
			getRightTreeNode().preOrder();
		}
	}

	/**
	 * 中序遍历树节点
	 * 
	 */
	public void midOrder()
	{
		// 存在左树节点，中序序遍历左树节点
		if (null != getLeftTreeNode())
		{
			getLeftTreeNode().midOrder();
		}

		// 打印当前树节点数据
		System.out.print(getData() + "\t");

		// 存在右树节点，中序遍历右树节点
		if (null != getRightTreeNode())
		{
			getRightTreeNode().midOrder();
		}
	}

	/**
	 * 后序遍历树节点
	 */
	public void backOrder()
	{
		// 存在左树节点，后序遍历左树节点
		if (null != getLeftTreeNode())
		{
			getLeftTreeNode().backOrder();
		}

		// 存在右树节点，后序遍历右树节点
		if (null != getRightTreeNode())
		{
			getRightTreeNode().backOrder();
		}

		// 打印当前树节点数据
		System.out.print(getData() + "\t");
	}

	public TreeNode getLeftTreeNode()
	{
		return leftTreeNode;
	}

	public void setLeftTreeNode(TreeNode leftTreeNode)
	{
		this.leftTreeNode = leftTreeNode;
	}

	public TreeNode getRightTreeNode()
	{
		return rightTreeNode;
	}

	public void setRightTreeNode(TreeNode rightTreeNode)
	{
		this.rightTreeNode = rightTreeNode;
	}

	public int getData()
	{
		return data;
	}

	public void setData(int data)
	{
		this.data = data;
	}

}

2、再定义一个二叉树类，主要负责包装树节点，构造出二叉树。如：对外提供添加数据方法，把数据转换成树节点，并添加到二叉树中；

还提供了前序、中序、后序的对外接口方法；

/**
 * 二叉树
 * 
 * @author dobuy
 */
public class BinaryTree
{
	/**
	 * 定义根节点
	 */
	private TreeNode root;

	/**
	 * 添加一个节点
	 * 
	 * @param data
	 */
	public void addNode(int data)
	{
		// 创建一个树节点
		TreeNode treeNode = new TreeNode(data);

		// 如果不是第一次创建，插入到根节点下面
		if (null != root)
		{
			root.addTreeNode(treeNode);
		}
		// 没有根节点时，把该节点设成根节点
		else
		{
			root = treeNode;
		}
	}

	/**
	 * 前序遍历树节点
	 */
	public void preOrder()
	{
		if (null != root)
		{
			System.out.print("preOrder:");
			root.preOrder();
			System.out.println();
		}
		else
		{
			System.out.println("there is no node in binary tree.");
		}
	}

	/**
	 * 中序遍历树节点
	 */
	public void midOrder()
	{
		if (null != root)
		{
			System.out.print("midOrder:");
			root.midOrder();
			System.out.println();
		}
		else
		{
			System.out.println("there is no node in binary tree.");
		}
	}

	/**
	 * 后序遍历树节点
	 */
	public void backOrder()
	{
		if (null != root)
		{
			System.out.print("backOrder:");
			root.backOrder();
			System.out.println();
		}
		else
		{
			System.out.println("there is no node in binary tree.");
		}
	}
}

3、提供Junit测试类，进行简单的功能测试：

import org.junit.Test;

public class BinaryTreeTest
{
	@Test
	public void test()
	{
		// 创建二叉树对象
		BinaryTree tree = new BinaryTree();

		// 添加树节点
		tree.addNode(10);
		tree.addNode(13);
		tree.addNode(5);
		tree.addNode(7);
		tree.addNode(3);
		tree.addNode(8);
		tree.addNode(4);
		tree.addNode(20);
		tree.addNode(15);
		tree.addNode(12);
		tree.addNode(11);

		// 前序遍历二叉树
		tree.preOrder();

		// 中序遍历二叉树
		tree.midOrder();

		// 后序遍历二叉树
		tree.backOrder();
	}

}

Junit运行BinaryTreeTest.java，测试结果如下

preOrder:10	5	3	4	7	8	13	12	11	20	15	
midOrder:3	4	5	7	8	10	11	12	13	15	20	
backOrder:4	3	8	7	5	11	12	15	20	13	10