二叉树的实现

package dataStructure.BinaryTree;
/**
 * 二叉树节点
 * @author xiaoyu
 *
 * @param <E>
 */
public class BinaryNode<E> {

	public  E data;
	BinaryNode<E> left;
	BinaryNode<E> right;
	
	public BinaryNode(BinaryNode<E> left ,E data,BinaryNode<E> right){
		this.left=left;
		this.data=data;
		this.right=right;
	}
	
	public BinaryNode(BinaryNode<E> left ,E data){
		this.left=left;
		this.data=data;
		
	}
	
	public BinaryNode(E data,BinaryNode<E> right){
	    this.data=data;
		this.right=right;
	}
	
	public BinaryNode(){
		this(null, null, null);
	}
	//判断是否是 叶子节点
	public boolean isLeaf(){
		if(this.right==null&&this.left==null)
			return true;
		else return false;
	}
	
	public E getDate(){
		return data;
	}
}

package stack;

public class LinkedQueue<T> implements QueueADT<T> {

	private int count; //队列中节点个数  
	
	private LinearNode<T> front,rear;//队列的头 尾节点
	
	public LinkedQueue(){      //构造方法；初始化
		count=0;
		front=rear=null;
		
	}
	
	
	//入 队列
	public void enqueue(T element) {
		//创建一个新节点
		LinearNode<T> node=new LinearNode<T>(element);
		
		if(isEmpty()){
			front=node;
		}else{
			rear.setNext(node);
		}
		
		rear=node;
		count++;
		
	}
	//出 队列
	public T delqueue() {
		if(isEmpty()){
			System.out.println("队列为空！");
		}
		else {
			T result=front.getElement();
			front=front.getNext();
			count--;
			
			if(isEmpty()){
				rear=null;
			}
			return result;
		}
		return null;
	}

	//获取头节点
	public T first() {
		T result=front.getElement();
		return result;
	}

	//判断是否为空
	public boolean isEmpty() {
		return count==0 ?true:false;
		
	}

	//队列大小
	public int size() {
		return count;
	}

}

package stack;
/**
 * 节点类，含有另个引用，一个指向链表的下一个LinearNode<T>节点，
 * 另一个指定本节点中存储的元素 
 * */
public class LinearNode <T>{
	/*指向下一个节点*/
	private LinearNode<T> next;
	/*本节点存储的元素*/
	private T element;
	
	 /*创建一个空的节点*/
	public LinearNode(){
		next=null;
		element=null;
	}
	
	 /*创建一个存储了特殊元素的节点*/
	public LinearNode(T element)
	{
		this.element=element;
		next=null;
	}
	 /*返回下一个节点*/
	public LinearNode<T> getNext(){
		return next;
	}
	   /*设置下一个节点*/
	public void setNext(LinearNode<T> node){
		next=node;
	}
	
	public T getElement(){
		return element;
	}
	
	public void setElement(T element){
		this.element=element;
	}
	
	
}

package stack;

public interface QueueADT<T> {
	/*向队列尾部添加一个元素*/
	public void enqueue(T element);
	
	/*从队列前部删除一个元素*/
	public T delqueue();
	
	/*队列前端那个元素*/
	public T first();
	
	/*判断队列是否为空*/
	public boolean isEmpty() ;
	
	/*队列中元素个数*/
	public int size();
	
	/*返回队列的字符串表示*/
	public String toString();
}

package dataStructure.BinaryTree;

import java.util.Stack;

import stack.LinkedQueue;

import com.sun.org.apache.regexp.internal.recompile;

/**
 * 二叉树 链表
 * @author xiaoyu
 *
 */
public class BinaryTree <E>{

	public void createTree(BinaryNode<E> p[],E[] element){
		int i,j;
		for(i=0;i<element.length;i++){
			p[i]=new BinaryNode(null,element[i],null);
			if(i>0){
				j=(i-1)/2;
				if(i%2==1){
					p[j].left=p[i];
				}
				else {
					p[j].right=p[i];
				}
			}
			
		}
		
	}
	
	//先根遍历
	public void preOrder(BinaryNode<E> p){
		if(p!=null){
			System.out.println(p.data);
			preOrder(p.left);
			preOrder(p.right);
		}
	}
	
	//先根遍历二叉树的非递归算法
    public void preOrderTraverse(BinaryNode<E> p)throws Exception{
        System.out.print("先根次序遍历（非递归）：  ");
        
        Stack<BinaryNode<E>> stack = new  Stack<BinaryNode<E>>();   //创建一个空栈
          while(p!=null || !stack.isEmpty()){//p非空或栈非空时
           if(p!=null){
            System.out.print(p.data+" ");    //访问结点
            stack.push(p);                   //p结点入栈
            p=p.left;                        //进入左子树
           }else{
                 p=stack.pop();                   //p指向出栈结点
                 p=p.right;                       //进入右子树
           }
          }
          System.out.println();
       }
    
	//中序遍历
	public void inOrder(BinaryNode<E> p){
		if(p!=null){
			inOrder(p.left);
			System.out.println(p.data);
			inOrder(p.right);
		}
	}

	//中根次序遍历二叉树的非递归算法
	 public void inOrderTraverse(BinaryNode p)throws Exception{
		  System.out.print("中根次序遍历（非递归）：  ");
		  Stack<BinaryNode<E>> stack = new Stack<BinaryNode<E>>();   //创建一个空栈
		   while(p!=null||!stack.isEmpty()){
		    if(p!=null){
		     stack.push(p);                   //p结点入栈
		     p=p.left;                        //进入左子树
		    }else{
		     p=stack.pop();                   //p指向出栈结点
		     System.out.print(p.data+" ");    //访问结点
		     p=p.right;                       //进入右子树
		    }
		   }
		   System.out.println();
		 }
	
	
	//后序遍历
	public void postOrder(BinaryNode<E> p){
		if(p!=null){
			postOrder(p.left);
			postOrder(p.right);
			System.out.println(p.data);
		}
	}
	
	//交换左右孩子节点
	public void swapChild(BinaryNode<E> p){
		if(p!=null){
			BinaryNode<E> temp=p.left;
			p.left=p.right;
			p.right=temp;
			swapChild(p.left);
			swapChild(p.right);
		}
	}
	
	//计算孩子节点个数
	public int countNode(BinaryNode<E> p){
		if(p!=null){
			return 1+countNode(p.left)+countNode(p.right);
		}
		else {
			return 0;
		}
	}
	
	//计算当前节点到叶子节点的深度
	public int height(BinaryNode<E> p){
		if(p!=null){
			int lc=height(p.left);
			int rc=height(p.right);
			return (lc>=rc)?lc+1:rc+1;
		}
		return 0;
		
	}
	
	//计算 节点p 下 的 叶子节点的个数
	 public int countLeaf(BinaryNode<E> p){
		  if(p==null)
		   return 0;
		  else if(p.left==null&&p.right==null)
		   return 1;
		  else
		   return countLeaf(p.left)+countLeaf(p.right);
		 }

	 //插入元素element作为p结点的孩子         
	 //若leftChild为true，插入结点作为左孩子，否则作为右孩子
	 public void insert(BinaryNode<E> p, E element, boolean leftChild){  
	      if (p!=null){
	       BinaryNode<E> q = new BinaryNode<E>(null,element,null);
	         if (leftChild){
	             q.left = p.left;                 //p结点的原左孩子成为q结点的左孩子
	             p.left = q;                      //q结点作为p结点的左孩子
	         } else{
	             q.right = p.right;               //p结点的原右孩子成为q结点的右孩子
	             p.right = q;                     //q结点作为p结点的右孩子
	              }
	      }
	 }
	
	//按层次遍历二叉树
	 public void levelOrder(BinaryNode p)throws Exception{
		 LinkedQueue<BinaryNode<E>> que=new LinkedQueue<BinaryNode<E>>(); //创建一个空队列
		   System.out.print("层次遍历：  ");
		   while(p!=null){
		    System.out.print(p.data+ " ");
		          if(p.left!=null)    
		             que.enqueue(p.left);             //p的左孩子结点入队
		          if(p.right!=null)
		               que.enqueue(p.right);            //p的右孩子结点入队
		           p = que.delqueue();
		   }
		   System.out.println();
		 }
	 
	
	 public static void main(String[] args)throws Exception {
		  // TODO Auto-generated method stub
		  BinaryTree bt=new BinaryTree();
		 
		  BinaryNode[] root=new BinaryNode[10];
		  Integer[] a=new Integer[10];
		  BinaryNode p=null;
		  for(int i=0;i<10;i++){
		   root[i]=null;
		   a[i]=(int)(Math.random()*100);
		  }
		  bt.createTree(root,a);
		  p=root[0];
		  bt.preOrder(p);
		  System.out.println();
		  bt.levelOrder(p);
		 }
	 
	 
	 
}

因为在  按层次遍历二叉树 时用到了 LinkedQueue ，所有其中又加进去了这个类的相关类。