以前沒有記筆記的習慣，結果發現曾經實現過的東西居然都忘了，現在又需要花時間去看，去寫，雖然又有所收穫，但是畢竟在走重複的路。

從今天起，開始打路標，為了以後少走回頭路：）

還請高手多指點，不勝感激！

用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