定义

二叉排序树或者是一棵空树，或者是具有下列性质的二叉树： 
（1）若左子树不空，则左子树上所有结点的键值均小于或等于它的根结点的键值； 
（2）若右子树不空，则右子树上所有结点的键值均大于或等于它的根结点的键值； 
（3）左、右子树也分别为二叉排序树；

如下图：

树的遍历方法：

（1）层次遍历：按照树的层次进行遍历，如图树：8、3、10、1、6、14、4、7、13

（2）先序遍历：节点遍历顺序为当前节点、左节点、右节点。如图树：8、3、1、6、4、7、10、14、13

（3）中序遍历：节点遍历顺序为左节点、当前节点、右节点。如图树：1、3、4、6、7、8、10、13、14

（4）后续遍历：节点遍历顺序为左节点、右节点、当前节点。如图树：1、4、7、6、3、8、13、14、10

从二叉排序树的中序遍历可以看出它是一个递增的有序表。
下面一段程序代码主要实现以下功能：二叉排序树的建立，插入，查询，四种遍历：

代码实现：

package yao.demo;
import java.util.*;
//二叉树的定义
class BinaryTree{
	int val;
	BinaryTree left;
	BinaryTree right;
	public BinaryTree(int val){
		this.val = val;
	}
}
/**
 * @author leo
 * @param f 如果在查找的过程中，查找成功，则f指向查找成功的节点；如果查找失败，f指向查找路径上的最后一个节点，也即待插入节点
 * @param root 指向二叉排序树的根节点
 */
public class BinarySortTree {
	static BinaryTree f;
	static BinaryTree root;
	
	//二叉排序树的创建
	public static void createBST(BinaryTree root, int key){
		BinaryTree newNode = new BinaryTree(key);
		if(key > root.val){
			if(root.right == null)
				root.right = newNode;
			else
				createBST(root.right, key);
		}
		else if(key < root.val){
			if(root.left == null)
				root.left = newNode;
			else
				createBST(root.left, key);
		}
		else{
			System.out.println("The node " + key + " is already exists");
			return;
		}
	}
	
	//二叉排序树的查找
	//如果查找成功，则f指向查找成功的节点；如果查找失败，f指向查找路径上的最后一个节点，也即待插入节点
	public static boolean sort(BinaryTree root, int key, BinaryTree p){
		if(root == null){
			f = p;
			System.out.println("查找失败！");
			return false;
		}
		else if(root.val == key){
			f = root;
			System.out.println("查找成功！");
			return true;
		}
		else if(root.val >= key)
			return sort(root.left, key, root);
		else 
			return sort(root.right, key, root);
	}
	
	//二叉排序树的插入
	public static void insert(BinaryTree rt, int key){
		if(sort(root, 100, null) == false){
			BinaryTree newNode = new BinaryTree(100);
			if(f == null)
				root = newNode;
			else if(key > f.val)
				f.right = newNode;
			else 
				f.left = newNode;
			System.out.println("插入成功！");
			return;
		}
		System.out.println("不允许插入重复元素！");
	}
	

	//二叉树的先序遍历
	public static void preOrder(BinaryTree rt){
		if(rt != null){
			System.out.print(rt.val + " ");
				preOrder(rt.left);
				preOrder(rt.right);
		}
	}
	
	//二叉树的中序遍历
	public static void inOrder(BinaryTree rt){
		if(rt != null){
			inOrder(rt.left);
			System.out.print(rt.val + " ");
			inOrder(rt.right);	
		}
	}
	
	//二叉树的后序遍历
	public static void postOrder(BinaryTree rt){
		if(rt != null){
			postOrder(rt.left);
			postOrder(rt.right);
			System.out.print(rt.val + " ");
		}
	}
	
	//二叉树的层次遍历
	//用队列实现
     public static void levelOrder(BinaryTree rt){
    	 if(rt == null)
    		 return;
    	 Queue<BinaryTree> queue = new LinkedList<BinaryTree>();
    	 queue.add(rt);
    	 while(!queue.isEmpty()){
    		 BinaryTree temp = queue.remove();
    		 System.out.print(temp.val + " ");
    		 if(temp.left != null)
    			 queue.add(temp.left);
    		 if(temp.right != null)
    			 queue.add(temp.right); 
    	 }
     }

	public static void main(String[] args) {
		int[] array = {35, 76, 12, 22, 16, 48, 90, 46, 9, 40};
		root = new BinaryTree(array[0]);
		for(int i = 1; i < array.length; i++){
			createBST(root, array[i]);
		}
		System.out.println(sort(root, 22, null));
		System.out.println(sort(root, 100, null));
		insert(root, 100);
	    System.out.print("先序遍历：");
	    preOrder(root);
	    System.out.println();
	    System.out.print("中序遍历：");
	    inOrder(root);
	    System.out.println();
	    System.out.print("后序遍历：");
	    postOrder(root);
	    System.out.println();
	    System.out.print("层次遍历：");
	    leverOrder(root);
	}
}