java实现二叉树及遍历

package TreePackage;

public interface TreeInterface <T>{
public T getRootData();
public int getHeight();
public int getNumberOfNodes();
public boolean isEmpty();
public void clear();

}

package TreePackage;
import java.util.Iterator;

public interface TreeInteratorInterface<T> {
public Iterator<T> getPreorderIterator();
public Iterator<T> getPostorderIterator();
public Iterator<T> getInorderIterator();
public Iterator<T> getLevelOrderIterator();
}

package TreePackage;
public interface BinaryTreeInterface<T> extends TreeInterface<T>,
		TreeInteratorInterface<T> {
	public void setTree(T rootData);

	public void setTree(T rootData, BinaryTreeInterface<T> leftTree,
			BinaryTreeInterface<T> rightTree);

}

package TreePackage;

import java.io.Serializable;

import org.w3c.dom.Node;

public interface BinaryNodeInterface <T>{
	public T getData();
	public void setData(T newData);
	public BinaryNodeInterface<T> getLeftChild();
	public BinaryNodeInterface<T> getRigthChild();
	public void setLeftChild(BinaryNodeInterface<T> leftChild);
	public void setRightChild(BinaryNodeInterface<T> rightChild);
	public boolean hasLeftChild();
	public boolean hasRightChild();
	public boolean isLeaf();
	public int getNumberOfNodes();
	public int getHeight();
	public BinaryNodeInterface<T> copy();
	}

class BinaryNode<T> implements BinaryNodeInterface<T>,Serializable
{

	private T data;
	private BinaryNode<T> left;
	private BinaryNode<T> right;
	public BinaryNode()
	{
		this(null);
	}
	public BinaryNode(T dataPortion)
	{
		this(dataPortion,null,null);
	}
	public BinaryNode(T dataPortion,BinaryNode<T> leftChild,BinaryNode<T> rightChild)
	{
		data=dataPortion;
		left=leftChild;
		right=rightChild;
	}
	@Override
	public T getData() {
		// TODO Auto-generated method stub
		return data;
	}

	@Override
	public void setData(T newData) {
		// TODO Auto-generated method stub
		data=newData;
	}

	@Override
	public BinaryNodeInterface<T> getLeftChild() {
		// TODO Auto-generated method stub
		return left;
	}

	@Override
	public BinaryNodeInterface<T> getRigthChild() {
		// TODO Auto-generated method stub
		return right;
	}

	@Override
	public void setLeftChild(BinaryNodeInterface<T> leftChild) {
		// TODO Auto-generated method stub
		left=(BinaryNode<T>) leftChild;
		
	}

	@Override
	public void setRightChild(BinaryNodeInterface<T> rightChild) {
		// TODO Auto-generated method stub
		right=(BinaryNode<T>) rightChild;
	}

	@Override
	public boolean hasLeftChild() {
		// TODO Auto-generated method stub
		return left!=null;
	}

	@Override
	public boolean hasRightChild() {
		// TODO Auto-generated method stub
		return right!=null;
	}

	@Override
	public boolean isLeaf() {
		// TODO Auto-generated method stub
		return (right==null)&&(left==null);
	}

	@Override
	public int getNumberOfNodes() {
		// TODO Auto-generated method stub
		int leftNumber=0;
		int rightNumber=0;
		if(left!=null)
			leftNumber=left.getNumberOfNodes();
		if(right!=null)
			rightNumber=right.getNumberOfNodes();
		return 1+leftNumber+rightNumber;
	}

	@Override
	public int getHeight() {
		// TODO Auto-generated method stub
		return getHeight(this);
	}
    
	private int getHeight(BinaryNode<T> node)
	{
		int height=0;
		if(node!=null)
		{
			height=1+Math.max(getHeight(node.left), getHeight(node.right));
		}
		return height;
	}
	@Override
	public BinaryNodeInterface<T> copy() {
		// TODO Auto-generated method stub
		BinaryNode<T> newRoot=new BinaryNode<T>(data);
		if(left!=null)
			newRoot.left=(BinaryNode<T>)left.copy();
		if(right!=null)
			newRoot.right=(BinaryNode<T>)right.copy();	
		return newRoot;
	}
	}

package TreePackage;

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

public class BinaryTree<T> implements BinaryTreeInterface<T>, Serializable {

	private BinaryNodeInterface<T> root;

	public BinaryTree() {
		root = null;
	}

	public BinaryTree(T rootData) {
		root = new BinaryNode<T>(rootData);
	}

	public BinaryTree(T rootData, BinaryTree<T> leftTree,
			BinaryTree<T> rightTree) {
		privateSetTree(rootData, leftTree, rightTree);
	}

	@Override
	public T getRootData() {
		// TODO Auto-generated method stub
		T rootData = null;
		if (root != null)
			rootData = root.getData();
		return rootData;
	}

	@Override
	public int getHeight() {
		// TODO Auto-generated method stub
		return root.getHeight();
	}

	@Override
	public int getNumberOfNodes() {
		// TODO Auto-generated method stub
		return root.getNumberOfNodes();
	}

	@Override
	public boolean isEmpty() {
		// TODO Auto-generated method stub
		return root == null;
	}

	@Override
	public void clear() {
		// TODO Auto-generated method stub
		root = null;
	}

	/**
	 * 先序遍历递归
	 */
	public void preorderTraverse() {
		preorderTraverse(root);
		System.out.println();
	}

	private void preorderTraverse(BinaryNodeInterface<T> node) {
		if (node != null) {
			System.out.print(node.getData() + "  ");
			preorderTraverse(node.getLeftChild());
			preorderTraverse(node.getRigthChild());
		}
	}

	/**
	 * 先序遍历非递归方法一
	 */
	public void preorderTraverseNoRecursion() {
		Stack<BinaryNodeInterface<T>> nodeStack = new Stack<BinaryNodeInterface<T>>();
		BinaryNodeInterface<T> currentNode = root;
		while ((currentNode != null) || (!nodeStack.isEmpty())) {
			if (currentNode != null) {
				System.out.print(currentNode.getData() + "  ");
				nodeStack.push(currentNode);
				currentNode = currentNode.getLeftChild();
			} else {
				currentNode = nodeStack.pop();
				currentNode = currentNode.getRigthChild();
			}
		}
		System.out.println();
	}

	/**
	 * 先序遍历非递归方法二
	 */
	public void preorderTraverseNoRecursion2() {
		Stack<BinaryNodeInterface<T>> nodeStack = new Stack<BinaryNodeInterface<T>>();
		BinaryNodeInterface<T> currentNode = root;

		if (currentNode != null) {
			nodeStack.push(currentNode);
			while (!nodeStack.isEmpty()) {
				currentNode = nodeStack.pop();
				System.out.print(currentNode.getData() + "  ");
				if (currentNode.getRigthChild() != null)
					nodeStack.push(currentNode.getRigthChild());
				if (currentNode.getLeftChild() != null)
					nodeStack.push(currentNode.getLeftChild());
			}
		}
		System.out.println();
	}

	/**
	 * 中序遍历递归
	 */
	public void inorderTraverse() {
		inorderTraverse(root);
		System.out.println();
	}

	private void inorderTraverse(BinaryNodeInterface<T> node) {
		if (node != null) {
			inorderTraverse(node.getLeftChild());
			System.out.print(node.getData() + "  ");
			inorderTraverse(node.getRigthChild());
		}
	}

	/**
	 * 中序遍历非递归
	 */
	public void inorderTraverseNoRecursion() {
		Stack<BinaryNodeInterface<T>> nodeStack = new Stack<BinaryNodeInterface<T>>();
		BinaryNodeInterface<T> currentNode = root;
		while ((currentNode != null) || (!nodeStack.isEmpty())) {
			if (currentNode != null) {
				nodeStack.push(currentNode);
				currentNode = currentNode.getLeftChild();
			} else {
				currentNode = nodeStack.pop();
				System.out.print(currentNode.getData() + "  ");
				currentNode = currentNode.getRigthChild();
			}
		}
		System.out.println();
	}

	/**
	 * 后序遍历递归
	 */
	public void postorderTraverse() {
		postorderTraverse(root);
		System.out.println();
	}

	private void postorderTraverse(BinaryNodeInterface<T> node) {
		if (node != null) {
			postorderTraverse(node.getLeftChild());
			postorderTraverse(node.getRigthChild());
			System.out.print(node.getData() + "  ");
		}
	}
    /**
     * 后序遍历非递归
     */
	public void postorderTraverseNoRecursion() {
		Stack<BinaryNodeInterface<T>> nodeStack = new Stack<BinaryNodeInterface<T>>();
		BinaryNodeInterface<T> currentNode = root;
		BinaryNodeInterface<T> preNode = null;
		if (currentNode != null) {
			nodeStack.push(currentNode);
			while (!nodeStack.isEmpty()) {
				currentNode = nodeStack.peek();
				if ((currentNode.getLeftChild() == null && currentNode
						.getRigthChild() == null)
						|| (preNode != null && (preNode == currentNode
								.getLeftChild() || preNode == currentNode
								.getRigthChild()))) {
					System.out.print(currentNode.getData()+"  ");
					nodeStack.pop();
					preNode=currentNode;
				}
				else {
					if(currentNode.getRigthChild()!=null)
						nodeStack.push(currentNode.getRigthChild());
					if(currentNode.getLeftChild()!=null)
						nodeStack.push(currentNode.getLeftChild());
				}
			}
		}
		System.out.println();
	}
    /**
     * 层次遍历非递归
     */
	public void levelorderTraverse()
	{
		Queue<BinaryNodeInterface<T>> nodeQueue=new LinkedList<BinaryNodeInterface<T>>();
		BinaryNodeInterface<T> currentNode=root;
		if(currentNode!=null)
		{
			nodeQueue.offer(currentNode);
			while(!nodeQueue.isEmpty())
			{
				currentNode=nodeQueue.poll();
				System.out.print(currentNode.getData()+"  ");
				if(currentNode.getLeftChild()!=null)
					nodeQueue.offer(currentNode.getLeftChild());
				if(currentNode.getRigthChild()!=null)
					nodeQueue.offer(currentNode.getRigthChild());			
			}
		}
		System.out.println();
	}
	@Override
	public Iterator<T> getPreorderIterator() {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public Iterator<T> getPostorderIterator() {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public Iterator<T> getInorderIterator() {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public Iterator<T> getLevelOrderIterator() {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public void setTree(T rootData) {
		// TODO Auto-generated method stub
		root = new BinaryNode<T>(rootData);
	}

	private void privateSetTree(T rootData, BinaryTree<T> leftTree,
			BinaryTree<T> rightTree) {
		root = new BinaryNode<T>(rootData);
		if ((leftTree != null) && !leftTree.isEmpty()) {
			root.setLeftChild(leftTree.root);
		}
		if ((rightTree != null) && !rightTree.isEmpty()) {
			if (rightTree != leftTree)
				root.setRightChild(rightTree.root);
			else
				root.setRightChild(rightTree.root.copy());
		}
		if ((leftTree != null) && (leftTree != this))
			leftTree.clear();
		if ((rightTree != null) && (rightTree != this))
			rightTree.clear();
	}

	@Override
	public void setTree(T rootData, BinaryTreeInterface<T> leftTree,
			BinaryTreeInterface<T> rightTree) {
		// TODO Auto-generated method stub
		privateSetTree(rootData, (BinaryTree<T>) leftTree,
				(BinaryTree<T>) rightTree);
	}

	protected void setRootData(T rootData) {
		root.setData(rootData);
	}

	protected void setRootNode(BinaryNodeInterface<T> rootNode) {
		root = rootNode;
	}

	protected BinaryNodeInterface<T> getRootNode() {
		return root;
	}

	public static void main(String[] argv) {
		BinaryTree<String> dTree = new BinaryTree<String>();
		dTree.setTree("d");
		BinaryTree<String> eTree = new BinaryTree<String>();
		eTree.setTree("e");
		BinaryTree<String> gTree = new BinaryTree<String>();
		gTree.setTree("g");
		BinaryTree<String> emptyTree = new BinaryTree<String>();
		BinaryTree<String> fTree = new BinaryTree<String>();
		fTree.setTree("f", emptyTree, gTree);
		BinaryTree<String> bTree = new BinaryTree<String>();
		bTree.setTree("b", dTree, eTree);
		BinaryTree<String> cTree = new BinaryTree<String>();
		cTree.setTree("c", fTree, emptyTree);
		BinaryTree<String> aTree = new BinaryTree<String>();
		aTree.setTree("a", bTree, cTree);
		System.out.println("跟节点： " + aTree.getRootData());
		System.out.println("二叉树高度： " + aTree.getHeight());
		System.out.println("二叉树节点数： " + aTree.getNumberOfNodes());
		aTree.inorderTraverse();
		aTree.inorderTraverseNoRecursion();
		aTree.preorderTraverse();
		aTree.preorderTraverseNoRecursion();
		aTree.preorderTraverseNoRecursion2();
		aTree.postorderTraverse();
		aTree.postorderTraverseNoRecursion();
		aTree.levelorderTraverse();
	}
}