二叉搜索树练习 POJ 1577

一棵二叉查找树是按二叉树结构来组织的。这样的树可以用链表结构表示，其中每一个结点都是一个对象。结点中除了数据外，还包括域left,right和p,它们分别指向结点的左儿子、右儿子，如果结点不存在，则为NULL。

它或者是一棵空树；或者是具有下列性质的二叉树：

1）若左子树不空，则左子树上所有结点的值均小于它的根结点的值；

（2）若右子树不空，则右子树上所有结点的值均大于它的根结点的值；

（3）左、右子树也分别为二叉查找树；

显然满足了上面的性质，那么二叉查找树按中序遍历就是按从小到大的顺序遍历，这也就是为什么叫排序树的原因，当然上面的小于和大于都可以根据自己的需求改变的。

二叉查找树的几个常用操作：查找，删除,插入.

例：POJ 1577
大意就是给出一个二叉搜索树，但给出的方式比较奇怪，是先给出最外层的叶子节点,然后揪掉这些叶子，把剩下的结点中变成叶子结点的再给出，这样一直到所有的结点都被揪掉。 最后要求这个二叉搜索树的先序遍历的结果。
[img]http://dl.iteye.com/upload/attachment/0077/0521/66c60927-d5a7-3811-8cb3-22e34686f06d.jpg[/img]
样例：

Sample Input

BDHPY
CM
GQ
K
*
AC
B
$
Sample Output

KGCBDHQMPY
BAC

此题就是要求建立一颗二叉树查找树，再进行前序遍历即可得到结果。
[img]http://dl.iteye.com/upload/attachment/0077/0525/c93f406b-4600-39d3-8b8b-e13c953ba963.gif[/img]

import java.util.*;
public class Main {

   BinarySearchTree< Character> root = new BinarySearchTree< Character>();//二叉查找树
   List<String>  list;

   public Main(List<String> list){
     this.list=list;
   }

   public void go(){
    String input=null;
    for(int i = list.size()-1; i >=0; i--){
	  input = list.get(i);
          for(int j = 0; j < input.length(); j++){
	   root.insert((Character)input.charAt(j));
	  }
     }
     root.printTree();
    }

    public static void main(String[] args){
      Scanner in =new Scanner(System.in);

      boolean stop = false;
      while(true){
        List< String> list = new ArrayList< String>();
        while(in.hasNext()){
         String input = in.next();
         if(input.charAt(0) =='*') break;
	 if(input.charAt(0) == '$'){
	  stop = true;
	  break;
	 }
	 list.add(input);
        }
	Main ma=new Main(list);		
	ma.go();
	if(stop){
	   return;
	}

	System.out.println();
     }
  }

}

class BinaryNode< T extends Comparable<T>> {//二叉查找树节点
	BinaryNode< T> left;
	BinaryNode< T> right;
	T element;

	public BinaryNode(T theElement){
		this(theElement, null, null);
	}
	public BinaryNode(T theElement, BinaryNode lt, BinaryNode rt){
		element = theElement;
		left = lt;
		right = rt;
	}
	public T getElement(){
		return this.element;
	}
	public BinaryNode< T> getLeft(){
		return this.left;
	}
	public BinaryNode< T> getRight(){
		return this.right;
	}
	public String toString(){
		return element + "";
	}
}

class BinarySearchTree< T extends Comparable<T>>{//二叉搜索树
	private BinaryNode< T> root;//根节点

	public BinarySearchTree(){//构造函数
		root = null;
	}
	public BinarySearchTree(BinaryNode< T> t){//构造函数
		root = t;
	}
	public void makeEmpty(){
		root = null;
	}
	public boolean isEmpty(){
		return root == null;
	}
	public T find(T x){
		return find(x, root).element;
	}

	public void insert(T x){
		root = insert(x, root);
	}
	public void printTree(){
		printTree(root);
	}


	private BinaryNode< T> find(T x, BinaryNode< T> t){//查找操作
		if(t == null){
			return null;
		}
		if(x.compareTo(t.element) < 0){
			return find(x, t.left);
		}
		else if(x.compareTo(t.element) == 0){
			return t;
		}
		else{
			return find(x, t.right);
		}
	}

	private BinaryNode< T> insert(T x, BinaryNode< T> t){//插入操作
		if(t == null){
			t = new BinaryNode< T>(x, null, null);
		}
		else if(x.compareTo(t.element) < 0){
			t.left = insert(x, t.left);
		}
		else if(x.compareTo(t.element) > 0){
			t.right = insert(x, t.right);
		}
		else;
		return t;
	}
	private void printTree(BinaryNode< T> t){//前序遍历二叉查找树
		if(t != null){	
			System.out.print(t.element);
			printTree(t.left);
			printTree(t.right);
		}
	}


}