BinarySearchTree

package com.zhuyu_deng.test;


public class BinarySearchTree<T extends Comparable<? super T>>
{
	// 结点
	private static class BinaryNode<T>
	{
		T element;
		BinaryNode<T> left;
		BinaryNode<T> right;

		BinaryNode(final T x, final BinaryNode<T> lt, final BinaryNode<T> rt)
		{
			element = x;
			left = lt;
			right = rt;
		}
	}

	// 根
	private BinaryNode<T> root;

	public BinarySearchTree()
	{
		root = null;
	}

	//
	public void makeEmpty()
	{
		root = null;
	}

	public boolean isEmpty()
	{
		return root == null;
	}

	public boolean contains(final T x)
	{
		return contains(x, root);
	}

	public void printTree()
	{
		if (isEmpty())
			System.out.println("Empty tree");
		else
			printTree(root);
	}

	public void insert(final T x)
	{
		root = insert(x, root);
	}
	
//	public void insert(final T x)
//	{
//		BinaryNode<T> p = null;  // y始终指向x的父亲
//		BinaryNode<T> cur = root;
//		
//		while (cur != null)
//		{
//			p = cur;
//			if (x.compareTo(cur.element) < 0)  // key[x] < key[cur], left , right
//				cur = cur.left;
//			else
//				cur = cur.right;
//		}
//		
//		if (root == null)  // 空树，设置根结点
//		{
//			root = new BinaryNode<T>(x, null, null);
//		}
//		else
//		{
//	rst < 0, rst > 0, rst = 0; 分这3种情况讨论，可以避免插入重复的结点。
//			if (x.compareTo(p.element) < 0)
//				p.left = new BinaryNode<T>(x, null, null);
//			else if (x.compareTo(p.element) > 0)
//
//				p.right = new BinaryNode<T>(x, null, null);
//			else
//				;
//				
//		}
//	}

	public void remove(final T x)
	{
		root = remove(x, root);
	}

	private boolean contains(final T x, final BinaryNode<T> t)
	{
		if (t == null)
			return false;
		final int rst = x.compareTo(t.element);
		if (rst < 0)
			return contains(x, t.left);
		else if (rst > 0)
			return contains(x, t.right);
		else
			;
		return true;
	}

	// find min

	 private BinaryNode<T> findMin( BinaryNode<T> t )
	 {
	     if( t == null )
	         return null;
	     else if( t.left == null )
	         return t;
	     return findMin( t.left );
	 }
	
	// find max
	@SuppressWarnings("unused")
	private BinaryNode<T> findMax(BinaryNode<T> t)
	{
		if (t != null)
			while (t.right != null)
				t = t.right;
		return t;
	}

	private BinaryNode<T> remove(final T x, BinaryNode<T> t)
	{
		if (t == null)
			return t; // Item not found; do nothing
		final int rst = x.compareTo(t.element);
		if (rst < 0)
			t.left = remove(x, t.left);
		else if (rst > 0)
			t.right = remove(x, t.right);
		else if (t.left != null && t.right != null)
		{
			t.element = findMin(t.right).element;
			t.right = remove(t.element, t.right);
		} else
		{
			t = (t.left != null) ? t.left : t.right;
		}
		return t;
	}
	
// 插入一个结点的recursive version
	private BinaryNode<T> insert(final T x, final BinaryNode<T> t)
	{
		if (t == null)
			return new BinaryNode<T>(x, null, null); // 作为根结点
		
		final int rst = x.compareTo(t.element);
		if (rst < 0)
			t.left = insert(x, t.left);
		else if (rst > 0)
			t.right = insert(x, t.right);
		else  // 这种情况对应的是相当，即原来二叉排序树中有这个结点不插入。
			;
		return t;  // t依然是根
	}
	


	
	private void printTree(final BinaryNode<T> t)
	{
		if (t != null)
		{
			printTree(t.left);
			System.out.println(t.element);
			printTree(t.right);
		}
	}

	
	
	@SuppressWarnings("unused")
	private int height(final BinaryNode<T> t)
	{
		if (t == null)
			return -1;
		else
			return 1 + Math.max(height(t.left), height(t.right));
	}
}