JAVA二叉树的建立和递归遍历

二叉树节点的接口

public interface BinaryNodeInterface<T> {
	public T getData();
	
	public void setData(T newData);
	
	public BinaryNodeInterface<T> getLeftChild();
	
	public BinaryNodeInterface<T> getRightChild();
	
	public void setLeftChild(BinaryNodeInterface<T> leftChild);
	
	public void setRightChild(BinaryNodeInterface<T> rightChild);
	
	public boolean hasLeftChild();
	
	public boolean hasRightChild();
	
	public boolean isLeaf();
	
	
	

}

二叉树节点类

public class BinaryNode<T> implements BinaryNodeInterface<T> {
	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 自动生成的方法存根
		return data;
	}

	@Override
	public void setData(T newData) {
		// TODO 自动生成的方法存根
		data=newData;
	}

	@Override
	public BinaryNodeInterface<T> getLeftChild() {
		// TODO 自动生成的方法存根
		return left;
	}

	@Override
	public BinaryNodeInterface<T> getRightChild() {
		// TODO 自动生成的方法存根
		return right;
	}

	@Override
	public void setLeftChild(BinaryNodeInterface<T> leftChild) {
		// TODO 自动生成的方法存根
		left=(BinaryNode<T>) leftChild;
	}

	@Override
	public void setRightChild(BinaryNodeInterface<T> rightChild) {
		// TODO 自动生成的方法存根
		right=(BinaryNode<T>) rightChild;
	}

	@Override
	public boolean hasLeftChild() {
		// TODO 自动生成的方法存根
		return left!=null;
	}

	@Override
	public boolean hasRightChild() {
		// TODO 自动生成的方法存根
		return right!=null;
	}

	@Override
	public boolean isLeaf() {
		// TODO 自动生成的方法存根
		return (left==null)&&(right==null);
	}
	
}

二叉树的实现类

import java.util.Stack;

public class BinaryTree<T>  {
	private BinaryNode<T> root;//创建一个根节点
	public BinaryTree(){
		root=null;
	}
	public BinaryTree(T rootData){
		root=new BinaryNode<T>(rootData);
	}
	
	public void preorderTraverse(){  //非递归遍历
		Stack< BinaryNode<T>> nodeStack=new Stack< BinaryNode<T>>();
		BinaryNode<T> node=root;
		while(!nodeStack.isEmpty()||(node!=null)){
			while(node!=null){
				System.out.print(node.getData()+" ");
				nodeStack.push(node);
				node=(BinaryNode<T>) node.getLeftChild();
			}

			if(!nodeStack.isEmpty()){
				node=(BinaryNode<T>)nodeStack.pop().getRightChild();
			}
		}		
	}
	public void preorderTraverse(BinaryNodeInterface<T> node){//递归遍历
		if(node!=null){
			System.out.print(node.getData()+" ");
			preorderTraverse(node.getLeftChild());
			preorderTraverse(node.getRightChild());
		}
		
	}
	public  void creatBinaryTree(BinaryNode<String> root) { //创建二叉树
		BinaryNode<String> nodeA=new BinaryNode<String>("A"); 
		BinaryNode<String> nodeB=new BinaryNode<String>("B"); 
		BinaryNode<String> nodeC=new BinaryNode<String>("C"); 
		BinaryNode<String> nodeD=new BinaryNode<String>("D"); 
		BinaryNode<String> nodeE=new BinaryNode<String>("E"); 
		BinaryNode<String> nodeF=new BinaryNode<String>("F"); 
		BinaryNode<String> nodeG=new BinaryNode<String>("G"); 
		root.setLeftChild(nodeA);
		root.setRightChild(nodeB);
		nodeA.setLeftChild(nodeC);
		nodeA.setRightChild(nodeD);
		nodeB.setLeftChild(nodeE);
		nodeE.setLeftChild(nodeF);
		nodeE.setRightChild(nodeG);		
	}
	public static void main(String[] args) {
		BinaryTree<String> s=new BinaryTree<String>("root");
		s.creatBinaryTree(s.root);
		System.out.println("前序递归遍历：");
		s.preorderTraverse(s.root);
		System.out.println("\n前序不递归遍历：");
		s.preorderTraverse();
	}
}

运行结果

前序递归遍历：
root A C D B E F G 
前序不递归遍历：
root A C D B E F G 

中序和后序遍历的话只要稍微改一下遍历方法的输出位置就可以了

}