二叉查找树

<span style="font-size:18px;">import java.util.LinkedList;

/**
 * 二叉查找树的实现，每个方法都有一个私有的方法
 * @author xxxu
 *
 */
public class BST {
	private Node root=null;
	
	private class Node{
		private Integer key; //键
		private String val;  //值
		private Node left;   //左节点
		private Node right;  //右节点
		private int N;       //以该节点为根的子树中的节点总数(包括自身)
		
		public Node(Integer key,String val,int N){
			this.key=key;
			this.val=val;
			this.N=N;
		}
	}
	
	public int size(){
		return size(root);
	}
	/**
	 * 统计该节点下一共有多少节点（包括自己）
	 * @param x
	 * @return
	 */
	private int size(Node x) {
		if(x==null){
			return 0;
		}else{
			return x.N;
		}
	}
	
	public String get(Integer key){
		return get(root,key);
	}
	/**
	 * 获取键对应的值
	 * @param x
	 * @param key
	 * @return
	 */
	private String get(Node x, Integer key) {
		if(x==null){
			return null;
		}
		if(key<x.key){
			return get(x.left,key);
		}else if(key>x.key){
			return get(x.right,key);
		}else{
			return x.val;
		}
	}
	
	public void put(Integer key,String val){
		root=put(root,key,val);
	}
	/**
	 * 如果key存在于以x为根节点的子树中则更新它的值
	 * 否则将以key和val为键值对的新结点插入到该子树中
	 * @param x
	 * @param key
	 * @param val
	 * @return
	 */
	private Node put(Node x, Integer key, String val) {
		if(x==null){
			return new Node(key,val,1);
		}
		if(key<x.key){
			x.left=put(x.left, key, val);
		}else if(key>x.key){
			x.right=put(x.right,key,val);
		}else{
			x.val=val;
		}
		x.N=size(x.left)+size(x.right)+1;
		return x;
	}
	/**
	 * 返回最小的键
	 * @return
	 */
	public Integer min(){
		return min(root).key;
	}
	
	private Node min(Node x) {
		if(x.left==null){
			return x;
		}
		return min(x.left);
	}
	
	public Integer max(){
		return max(root).key;
	}
	
	private Node max(Node x) {
		if(x.right==null){
			return x;
		}
		return max(x.right);
	}

	public void deleteMin(){
		root=deleteMin(root);
	}
	/**
	 * 删除最小的键
	 * @param x
	 * @return
	 */
	private Node deleteMin(Node x) {
		if(x.left==null){
			return x.right;
		}
		x.left=deleteMin(x.left);
		x.N=size(x.left)+size(x.right)+1;
		return x;
	}
	
	public void delete(Integer key){
		root=delete(root,key);
	}
	/**
	 * 删除全是递归，理解起来有点费劲，仔细揣摩，用笔画图帮助理解
	 * @param x
	 * @param key
	 * @return
	 */
	private Node delete(Node x, Integer key) {
		if(x==null){
			return null;
		}
		if(key<x.key){
			x.left=delete(x.left,key);
		}else if(key>x.key){
			x.right=delete(x.right,key);
		}else{
			if(x.right==null){
				return x.left;
			}
			if(x.left==null){
				return x.right;
			}
			Node t=x;
			x=min(t.right);  //找出删除节点的右节点最小的节点，替换到删除的节点上
			x.right=deleteMin(t.right);//既然替换到删除的节点上，那么这个节点就要删除
			x.left=t.left;
		}
		x.N=size(x.left)+size(x.right)+1;
		return x;
	}
	
	public void zhongPrint(){
		zhongPrint(root);
		System.out.println();
	}
	/**
	 * 中序遍历
	 * @param x
	 */
	private void zhongPrint(Node x) {
		if(x==null){
			return;
		}
		zhongPrint(x.left);
		System.out.print(x.val+" ");
		zhongPrint(x.right);
	}

	public void qianPrint(){
		qianPrint(root);
		System.out.println();
	}
	/**
	 * 前序遍历
	 * @param x
	 */
	private void qianPrint(Node x) {
		if(x==null){
			return;
		}
		System.out.print(x.val+" ");
		qianPrint(x.left);
		qianPrint(x.right);
	}

	public void houPrint(){
		houPrint(root);
		System.out.println();
	}
	/**
	 * 后序遍历
	 * @param x
	 */
	private void houPrint(Node x) {
		if(x==null){
			return;
		}
		houPrint(x.left);
		houPrint(x.right);
		System.out.print(x.val+" ");
	}
	
	public void guangDuPrint(){
		guangDuPrint(root);
		System.out.println();
	}
	/**
	 * 利用链表进行广度(宽度)遍历
	 * @param x
	 */
	private void guangDuPrint(Node x) {
		if(x==null){
			return;
		}
		LinkedList<Node> linkedList=new LinkedList<Node>();
		linkedList.add(x);
		while(linkedList.size()>0){
			Node y=linkedList.poll();
			if(y!=null){
				System.out.print(y.key+" ");
			}
			if(y.left!=null){
				linkedList.add(y.left);
			}
			if(y.right!=null){
				linkedList.add(y.right);
			}
		}
	}
}</span>