二叉排序树

二叉排序树的性质：

1. 左子树（如果存在）上所有节点的关键字都小于根节点的关键字。
2. 右子树（如果存在）上所有节点的关键字都大于根节点的关键字。
3. 左子树和右子树也是二叉排序树。

代码。。

public class App 
{

	public static void main(String[] arg) {
		int[]array= {39,11,68,46,75,23,71,8,86,34};
		BSTree bTree=new BSTree(array);
		bTree.preOrder();
		System.out.println("");
		System.out.println(bTree.find(23));
		bTree.delete(39);
		bTree.preOrder();
		System.out.println("");
		System.out.println(bTree.find(8));
	}
	
	static class BSTree{
		class Node{
			int data;
			Node leftChild,rightChild;
			@Override
			public String toString() {
				// TODO Auto-generated method stub
				return String.valueOf(data);
			}
		}
		
		Node root;
		public BSTree(int[] array) {
			for(int a:array) {
				insert(a);
			}
		}
		/***
		 * 前序遍历
		 */
		void preOrder() {
			preOrder(root);
		}
		void preOrder(Node p) {
			if(p==null) {
				return;
			}
			System.out.print(p.data+" ");
			preOrder(p.leftChild);
			preOrder(p.rightChild);
		}
		
		Node find(int k,Node p) {
			if(p==null) {
				return null;
			}
			if(k<p.data) {
				return find(k, p.leftChild);
			}else if(k>p.data) {
				return find(k, p.rightChild);
			}else {
				return p;
			}
		}
		Node find(int k) {
			return find(k,root);
		}
		void insert(int k,Node p) {
			if(p==null) {//为null时，必定时根节点，因为在调用insert时已经判断了引用是否为null
				root=new Node();
				root.data=k;
				return;
			}
			if(k<p.data) {
				if(p.leftChild==null) {
					p.leftChild=new Node();
					p.leftChild.data=k;
				}else {
					insert(k, p.leftChild);
				}
			}else if(k>p.data) {
				if(p.rightChild==null) {
					p.rightChild=new Node();
					p.rightChild.data=k;
				}else {
					insert(k, p.rightChild);
				}
			}
			//若存在，啥都不干
		}
		/***
		 * 插入一个节点到二叉排序树中
		 * @param k
		 * @param p
		 * @return 新的根节点
		 */
		Node insert2(int k,Node p) {
			if(p==null) {
				Node tNode=new Node();
				tNode.data=k;
				return tNode;
			}
			if(k<p.data) {
				p.leftChild=insert2(k, p.leftChild);
			}else if(k>p.data) {
				p.rightChild=insert2(k, p.rightChild);
			}
			//若存在，啥都不干
			return p;
		}
		void insert(int k) {
//			insert(k, root);
			root=insert2(k, root);
		}
		/***
		 * 	查找最小的节点
		 * @param p 子树的根节点
		 */
		Node min(Node p) {
			Node temp=p;
			while(temp.leftChild!=null) {
				temp=temp.leftChild;
			}
			return temp;
		}
		/***
		 * 	删除以p为根节点的最小节点
		 * @param p
		 * @return 返回新二叉查找树的根节点
		 */
		Node deleteMin(Node p) {
			if(p.leftChild==null) {
				return p.rightChild;
			}
			p.leftChild=deleteMin(p.leftChild);
			return p;
		}
		/***
		 * 删除值为k的结点
		 * @param k
		 * @param p
		 * @return 返回新二叉树的根节点
		 */
		Node delete(int k,Node p) {
			if(p==null) {
				return null;
			}
			if(k<p.data) {
				 p.leftChild=delete(k, p.leftChild);
				 return p;
			}else if(k>p.data) {
				p.rightChild=delete(k, p.rightChild);
				return p;
			}else {
				if(p.leftChild==null) {
					return p.rightChild;
				}else if(p.rightChild==null) {
					return p.leftChild;
				}else {
					Node tNode=min(p.rightChild);
					tNode.rightChild=deleteMin(p.rightChild);
					tNode.leftChild=p.leftChild;
					return tNode;
				}
			}
		}
		void delete(int k) {
			root=delete(k,root);
		}
	}

}

二叉排序树的查找性能和二叉树的建立有关，如果建立的是完全二叉树，其平均查找性能最佳为log2n。当二叉排序树退化成单支树时，性能最差为(n+1)/2，与顺序表的平均查找长度相同。

参考：

https://blog.csdn.net/u010853261/article/details/54174609