二叉搜索树特征
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);
}
}