二叉搜索树的实现（JAVA）

二叉搜索树特征

1. 左孩子小于根节点

2. 右孩子大于根节点

3. 左右子树均是二叉搜索树

4. 二叉搜索树中序遍历可以获得一个从小到大的有序数组

二叉搜索树的查找效率

 如图所示，查找效率在最坏情况下是O(n)，就比如那种最不均衡的，只有右子树或者只有左子树

但是在平均情况，二叉搜索树的查找效率为O(logn)

二叉搜索树常用接口

find(x) 递归实现

	public boolean find(SearchTreeNode node , int k) 
	{
		if (node == null) 
		{
			return false;
		}
		else 
		{
			if (node.data == k) 
			{
				return true;
			}
			else if (node.data > k) 
			{
				return find(node.leftchild,k);
			}
			else 
			{
				return find(node.rightchild,k);
			}
		}

	}

findmin寻找最小

public int findMin(SearchTreeNode node) throws Exception
	{
		if (node == null) 
		{
			throw new Exception("The tree is empty");
		}
		else 
		{
			if (node.leftchild != null) 
			{
				return findMin(node.leftchild);
			}
			else 
			{
				return node.data;
			}
		}
	}

findmax寻找最大

public int findMax(SearchTreeNode node) throws Exception
	{
		if (node == null) 
		{
			throw new Exception("The tree is empty");
		}
		else 
		{
			if (node.rightchild != null) 
			{
				return findMax(node.rightchild);
			}
			else 
			{
				return node.data;
			}
		}
	}

插入insert

public void insertBST(SearchTreeNode node,int key) throws Exception
	{
		if (node == null) 
		{
			node = new SearchTreeNode(key);
		}
		else 
		{
			if (node.data > key)
			{
				if (node.leftchild == null) 
				{
					node.leftchild = new SearchTreeNode(key);
					node.leftchild.parent = node;
				}
				else 
				{
					insertBST(node.leftchild,key); 
				}
			}
			else if (node.data < key) 
			{
				if (node.rightchild == null) 
				{
					node.rightchild = new SearchTreeNode(key);
					node.rightchild.parent = node;
				}
				else 
				{
					insertBST(node.rightchild,key); 
				}
			}
			else 
			{
				throw new Exception("insert data is error");
			}
			
		}
	}

删除，删除策略为，将该节点删除，然后将右子树的最小节点或者左子树的最大节点替代当前节点，但通常情况下使用右子树的最小节点。

	public void remove(SearchTreeNode p,SearchTreeNode c) throws Exception 
	{
		if(c.leftchild == null && c.rightchild == null) 
		{
			if (p.rightchild == c) 
			{
				p.rightchild  = null;
			}
			else 
			{
				p.leftchild  = null;
			}
		}
		else if (c.leftchild != null && c.rightchild == null) 
		{
			if (p.rightchild == c) 
			{
				p.rightchild  = c.leftchild;
			}
			else 
			{
				p.leftchild   = c.leftchild;
			}
		}
		else if (c.leftchild == null && c.rightchild != null) 
		{
			if (p.rightchild == c) 
			{
				p.rightchild  = c.rightchild;
			}
			else 
			{
				p.leftchild   = c.rightchild;
			}
		}
		else 
		{
			SearchTreeNode ret = this.findMinNode(c.rightchild);
			int keyvalue = ret.data;
			c.data = keyvalue;
			this.remove(ret.parent,ret);
		}
	}
	public void delete(int k ) throws Exception
	{

		SearchTreeNode ret = this.find(this.root, k);
		SearchTreeNode parent = ret.parent;
		if (ret != null && parent != null) 
		{
			remove(parent,ret);
		}
		else if (ret != null && parent == null) 
		{
			SearchTreeNode newroot = this.findMinNode(this.root.rightchild);
			if (newroot != null) {
				int keyvalue = newroot.data;
				this.delete(keyvalue);
				this.root.data = keyvalue;
			}
			else 
			{
				this.root = this.root.leftchild;
			}
		}

	}

整体代码入下

class SearchTreeNode
{
	int data;
	SearchTreeNode leftchild;
	SearchTreeNode rightchild;
	SearchTreeNode parent;
	SearchTreeNode()
	{
		data = 0;
		leftchild = null;
		rightchild = null;
		parent = null;
	}
	SearchTreeNode(int value)
	{
		data = value;
		leftchild = null;
		rightchild = null;
		parent = null;
	}
	SearchTreeNode(int value,SearchTreeNode left,SearchTreeNode right,SearchTreeNode p)
	{
		data = value;
		leftchild = left;
		rightchild = right;
		parent = p;
	}

}
public class BinarySearchTree {
	SearchTreeNode root;
	BinarySearchTree()
	{
		this.root = null;
	}
	BinarySearchTree(SearchTreeNode node)
	{
		this.root = node;
	}
	public boolean contains(SearchTreeNode node , int k) 
	{
		if (node == null) 
		{
			return false;
		}
		else 
		{
			if (node.data == k) 
			{
				return true;
			}
			else if (node.data > k) 
			{
				return contains(node.leftchild,k);
			}
			else 
			{
				return contains(node.rightchild,k);
			}
		}

	}
	public SearchTreeNode find(SearchTreeNode node , int k) 
	{
		if (node == null) 
		{
			return null;
		}
		else 
		{
			if (node.data == k) 
			{
				return node;
			}
			else if (node.data > k) 
			{
				return find(node.leftchild,k);
			}
			else 
			{
				return find(node.rightchild,k);
			}
		}

	}
	public SearchTreeNode findMinNode(SearchTreeNode node) throws Exception
	{
		if (node == null) 
		{
			throw new Exception("The tree is empty");
		}
		else 
		{
			if (node.leftchild != null) 
			{
				return findMinNode(node.leftchild);
			}
			else 
			{
				return node;
			}
		}
	}
	public int findMin(SearchTreeNode node) throws Exception
	{
		if (node == null) 
		{
			throw new Exception("The tree is empty");
		}
		else 
		{
			if (node.leftchild != null) 
			{
				return findMin(node.leftchild);
			}
			else 
			{
				return node.data;
			}
		}
	}
	public int findMax(SearchTreeNode node) throws Exception
	{
		if (node == null) 
		{
			throw new Exception("The tree is empty");
		}
		else 
		{
			if (node.rightchild != null) 
			{
				return findMax(node.rightchild);
			}
			else 
			{
				return node.data;
			}
		}
	}
	public void insertBST(SearchTreeNode node,int key) throws Exception
	{
		if (node == null) 
		{
			node = new SearchTreeNode(key);
		}
		else 
		{
			if (node.data > key)
			{
				if (node.leftchild == null) 
				{
					node.leftchild = new SearchTreeNode(key);
					node.leftchild.parent = node;
				}
				else 
				{
					insertBST(node.leftchild,key); 
				}
			}
			else if (node.data < key) 
			{
				if (node.rightchild == null) 
				{
					node.rightchild = new SearchTreeNode(key);
					node.rightchild.parent = node;
				}
				else 
				{
					insertBST(node.rightchild,key); 
				}
			}
			else 
			{
				throw new Exception("insert data is error");
			}
			
		}
	}
	public void remove(SearchTreeNode p,SearchTreeNode c) throws Exception 
	{
		if(c.leftchild == null && c.rightchild == null) 
		{
			if (p.rightchild == c) 
			{
				p.rightchild  = null;
			}
			else 
			{
				p.leftchild  = null;
			}
		}
		else if (c.leftchild != null && c.rightchild == null) 
		{
			if (p.rightchild == c) 
			{
				p.rightchild  = c.leftchild;
			}
			else 
			{
				p.leftchild   = c.leftchild;
			}
		}
		else if (c.leftchild == null && c.rightchild != null) 
		{
			if (p.rightchild == c) 
			{
				p.rightchild  = c.rightchild;
			}
			else 
			{
				p.leftchild   = c.rightchild;
			}
		}
		else 
		{
			SearchTreeNode ret = this.findMinNode(c.rightchild);
			int keyvalue = ret.data;
			c.data = keyvalue;
			this.remove(ret.parent,ret);
		}
	}
	public void delete(int k ) throws Exception
	{

		SearchTreeNode ret = this.find(this.root, k);
		SearchTreeNode parent = ret.parent;
		if (ret != null && parent != null) 
		{
			remove(parent,ret);
		}
		else if (ret != null && parent == null) 
		{
			SearchTreeNode newroot = this.findMinNode(this.root.rightchild);
			if (newroot != null) {
				int keyvalue = newroot.data;
				this.delete(keyvalue);
				this.root.data = keyvalue;
			}
			else 
			{
				this.root = this.root.leftchild;
			}
		}

	}
	public void preOrder(SearchTreeNode node) 
	{
		if (node != null) 
		{
			System.out.println(node.data);
			preOrder(node.leftchild);
			preOrder(node.rightchild);
		}
	}
	public void inOrder(SearchTreeNode node) 
	{
		if (node != null) 
		{
			inOrder(node.leftchild);
			System.out.println(node.data);
			inOrder(node.rightchild);
		}
	}
	public void postOrder(SearchTreeNode node) 
	{
		if (node != null) 
		{
			postOrder(node.leftchild);
			postOrder(node.rightchild);
			System.out.println(node.data);
		}
	}
	public static void main(String[] args) throws Exception 
	{
		SearchTreeNode node = new SearchTreeNode(6);
		BinarySearchTree tree = new BinarySearchTree(node);
		tree.insertBST(tree.root, 2);
		tree.insertBST(tree.root, 1);
		tree.insertBST(tree.root, 5);
		tree.insertBST(tree.root, 3);
		tree.insertBST(tree.root, 4);
		tree.insertBST(tree.root, 8);
		tree.preOrder(tree.root);
		tree.delete(2);
		tree.preOrder(tree.root);
		

	}
}