二叉树的实现Java

/**
 * 二叉树结点类
 * @author liangxiamoyi
 *
 */
public class BinTreeNode {
	/**
	 * 左子节点
	 */
	protected BinTreeNode left;
	/**
	 * 右子节点
	 */
	protected BinTreeNode right;
	/**
	 * 数据域
	 */
	protected char data;
	/**
	 * 构造方法
	 * @param item 数据
	 * @param left 左子节点
	 * @param right 右子节点
	 */
	public BinTreeNode(char item,BinTreeNode left,BinTreeNode right){
		this.data=item;
		this.left=left;
		this.right=right;
	}
}

<pre name="code" class="java">import java.util.Scanner;
/**
 * 二叉树类
 * @author liangxiamoyi
 *
 */
public class BinTree {
	/**
	 * 根节点
	 */
	private BinTreeNode root;
	/**
	 * 构造二叉树时的输入结束符
	 */
	private char stop;
	/**
	 * 构造方法
	 * @param root 根节点
	 */
	public BinTree(BinTreeNode root){
		this.root=root;
	}
	/**
	 * 获得根节点
	 * @return
	 */
	public BinTreeNode getRoot(){
		return root;
	}
	/**
	 * 设置根节点
	 * @param root 根节点
	 */
	public void setRoot(BinTreeNode root){
		this.root=root;
	}
	/**
	 * 获得stop数据
	 * @return
	 */
	public char getStop(){
		return this.stop;
	}
	/**
	 * 设置stop
	 * @param stop 结束字符
	 */
	public void setStop(char stop){
		this.stop=stop;
	}
	/**
	 * 在以root为根节点的二叉树中找结点p的父节点
	 * @param root 根节点
	 * @param p 结点
	 * @return p的父节点
	 */
	public BinTreeNode getFather(BinTreeNode root,BinTreeNode p){
		BinTreeNode t;
		if(root==null||p==null){
			return null;
		}
		if(root.left==p||root.right==p){
			return root;
		}
		if((t=getFather(root.left,p))!=null){
			return t;
		}
		else return getFather(root.right, p);
	}
	/**
	 * 在以root为根节点的二叉树中找数据为item的结点
	 * @param root 根节点
	 * @param item 数据
	 * @return 数据为item的结点
	 */
	public BinTreeNode find(BinTreeNode root,char item){
		BinTreeNode p;
		if(root==null)return null;
		else if(root.data==item)return root;
		else if((p=find(root.left,item))!=null)return p;
		else return find(root.right,item);
	}
	/**
	 * 删除以t为根节点的子树
	 * @param t 子树的根节点
	 */
	public void delSubTree(BinTreeNode t){
		if(t==null)return;
		else if(t==root){
			root=null;
			return;
		}
		else{
			BinTreeNode p=getFather(root, t);
			if(p!=null){
				if(p.left==t){
					p.left=null;
				}
				else p.right=null;
			}
		}
	}
	/**
	 * 先根遍历
	 * @param t
	 */
	public void preOrder(BinTreeNode t){
		if(t!=null){
			System.out.print(t.data+" ");
			preOrder(t.left);
			preOrder(t.right);
		}
	}
	/**
	 * 非递归先根遍历
	 * @param t 根节点
	 */
	public void NorecPreOrder(BinTreeNode t){
		if(t==null){
			return ;
		}
		AStack<BinTreeNode> a=new AStack<BinTreeNode>(20);
		while(t!=null||!a.isEmpty()){
			while(t!=null){
				a.push(t);
				System.out.print(t.data+" ");
				t=t.left;
			}
			if(a.isEmpty())return;
			t=a.pop();
			t=t.right;
		}
	}
	/**
	 * 中根遍历
	 * @param t
	 */
	public void inOrder(BinTreeNode t){
		if(t!=null){
			inOrder(t.left);
			System.out.print(t.data+" ");
			inOrder(t.right);
		}
	}
	/**
	 * 非递归中根遍历
	 * @param t 根节点
	 */
	public void norecInOrder(BinTreeNode t){
		if (t==null){
			return ;
		}
		//顺序栈
		AStack<BinTreeNode> s=new AStack<BinTreeNode>(20);
		while(t!=null||!s.isEmpty()){
			while(t!=null){
				s.push(t);
				t=t.left;
			}
			if(s.isEmpty())return;
			t=s.pop();
			System.out.print(t.data+" ");
			t=t.right;
		}
	}
	/**
	 * 后根遍历
	 * @param t
	 */
	public void postOrder(BinTreeNode t){
		if(t!=null){
			postOrder(t.left);
			postOrder(t.right);
			System.out.print(t.data+" ");
		}
	}
	/**
	 * 非递归后根遍历
	 * @param t 根节点
	 */
	public void norecPostOrder(BinTreeNode t){
		if(t==null)return;
		AStack<AssBinTreeNode> s=new AStack<>(20);
		AssBinTreeNode ass,lass,rass;
		ass=new AssBinTreeNode(t, 0);
		s.push(ass);
		int i=0;
		while(!s.isEmpty()){
			ass=s.pop();
			t=ass.ptr;
			i=ass.flag;
			if(i==0){
				ass.setFlag(1);
				s.push(ass);
				if(t.left!=null){
					lass=new AssBinTreeNode(t.left, 0);
					s.push(lass);
				}
			}
			if(i==1){
				ass.setFlag(2);
				s.push(ass);
				if(t.right!=null){
					rass=new AssBinTreeNode(t.right, 0);
					s.push(rass);
				}
			}
			if(i==2){
				System.out.print(t.data+" ");
			}
		}
	}
	/**
	 * 层次遍历
	 * @param t 根节点
	 */
	public void levelOrder(BinTreeNode t){
		if(t==null){
			return ;
		}
		AQueue<BinTreeNode> p=new AQueue<BinTreeNode>(20);
		p.insert(t);
		BinTreeNode q;
		while(!p.isEmpty()){
			q=p.delete();
			System.out.print(q.data+" ");
			if(q.left!=null)p.insert(q.left);
			if(q.right!=null)p.insert(q.right);
		}
	}
	/**
	 * 创建一棵二叉树，调用create()函数
	 * @param stop 结束字符
	 */
	public void createBinTree(char stop){
		setStop(stop);
		root=create();
	}
	/**
	 * 创建二叉树
	 * @return 根节点
	 */
	public BinTreeNode create(){
		BinTreeNode t,l,r;
		char item;
		Scanner sc=new Scanner(System.in);
		item=sc.next().charAt(0);
		if(item==stop){
			t=null;
			return t;
		}
		else{
			t=new BinTreeNode(item, null, null);
			l=create();
			t.left=l;
			r=create();
			t.right=r;
			return t;
		}
	}
	//测试
	public static void main(String[] args){
		//测试数据为：abzcdzzzefzzz
		BinTree bt=new BinTree(null);
		bt.createBinTree('z');
		System.out.println("先根遍历：");
		bt.preOrder(bt.root);
		System.out.println();
		bt.NorecPreOrder(bt.root);
		System.out.println();
		System.out.println("中根遍历：");
		bt.inOrder(bt.root);
		System.out.println();
		bt.norecInOrder(bt.root);
		System.out.println();
		System.out.println("后根遍历：");
		bt.postOrder(bt.root);
		System.out.println();
		bt.norecPostOrder(bt.root);
		System.out.println();
		System.out.println("层次遍历：");
		bt.levelOrder(bt.root);
		System.out.println();
		BinTreeNode btn=bt.find(bt.root, 'd');
		System.out.println("d的父节点为：");
		System.out.println(bt.getFather(bt.root, btn).data);
		bt.delSubTree(bt.find(bt.root, 'c'));
		System.out.println("删除子树后，先根遍历：");
		bt.preOrder(bt.root);
		
	}
}

测试结果：