二叉搜索树的实现（包含插入、查找、遍历、删除等）【Java版】

//定义树的结点
private class Node {
private Key  key; //键，相当于字典中的单词
private Value  value;//值，与键对应，相当于字典中单词的含义
private Node left; //左孩子结点
private Node right; //右孩子结点

//结点的构造函数
public Node(Key key,Value value) {
this.key=key;
this.value=value;
this.left=null;
this.right=null;
}

}

//树的根节点
private Node root;
//树中结点的个数
private int count;
//树中结点的总数

public int size() {
return count;
}
public boolean isEmpty() {
return count==0;
}

1.向二叉搜索树中插入新的节点，

//递归实现，也可以用非递归来实现
public void insert(Key key,Value value) {
root=insert(root,key, value);
}
//重写，向以node为根节点的二叉搜索树中插入新节点<key,value>，
//返回插入新节点后二叉搜索树的根
private Node insert(Node node,Key key,Value value) {
//处理递归到底的情况
if(node==null) {
count++;
return new Node(key, value);
}
//不支持重复元素，如果有重复，就更新
if(key==node.key) {
node.value=value;
}else if(node.key.compareTo(key)<0) {
node.right=insert(node.right, key, value);
}else {
node.left=insert(node.left, key, value);
}
return node;
}

2.在二叉搜索树中看是否包含键值为key的元素

public boolean contain(Key key) {
//递归实现，查找以root为根节点的树中是否包含key
return contain(root,key);
}
private boolean contain(Node node, Key key) {
//处理递归到底的情况
if(node==null)
return false;
if(key==node.key)
return true;
else if (node.key.compareTo(key)>0) {
return contain(node.left,key);
}else {
return contain(node.right, key);
}
}

3.在二叉搜索树中查找节点[找出key所对应的value]

public Value search(Key key) {
return search(root,key);
}
//在以node为根的二叉搜索树中查找key所对应的value
private Value search(Node node,Key key) {
if(node==null)
return null;

if(key==node.key)
return node.value;
else if(node.key.compareTo(key)>0)
return search(node.left,key);
else {
return search(node.right, key);
}
}

4.对二叉搜索树进行前序遍历【深度优先遍历】

public void preOrder() {
preOrder(root);
}
//对以node为根的二叉搜索树进行前序遍历
private void preOrder(Node node) {
if(node!=null) {
System.out.print(node.key+" ");
preOrder(node.left);
preOrder(node.right);
}
}

5.对二叉搜索树进行中序遍历【深度优先遍历】

public void inOrder() {
inOrder(root);
}
//对以node为根的二叉搜索树进行中序遍历
**//中序遍历即完成从小到大排序**
private void inOrder(Node node) {
if(node!=null) {
inOrder(node.left);
System.out.print(node.key+" ");
inOrder(node.right);
}
}

6.对二叉搜索树进行后序遍历【深度优先遍历】

public void postOrder() {
postOrder(root);
}
//对以node为根的二叉搜索树进行后序遍历
**//后序遍历可以释放二叉搜索树的空间**
private void postOrder(Node node) {
if(node!=null) {
postOrder(node.left);
postOrder(node.right);
System.out.print(node.key+" ");
}
}

7.对二叉搜索树进行层序遍历【广度优先遍历】

public void levelOrder() {
levelOrder(root);
}
//对以node为根的二叉搜索树进行层序遍历
public void levelOrder(Node node) {
LinkedList<Node> queue=new LinkedList<>();
queue.add(node);
while(!queue.isEmpty()) {
Node node2=queue.poll();
System.out.print(node2.key);
if(node2.left != null)
queue.add(node2.left);
if(node2.right!=null)
queue.add(node2.right);
}
}

8.寻找二叉搜索树的最小节点

public Node minNum() {
return minNum(root);
}
//寻找以node为根的二叉搜索树的最小节点
private Node minNum(Node node) {
if(node.left==null)
return node;
return minNum(node.left);
}

9.寻找二叉搜索树的最大值key

public Key maxNum() {
return maxNum(root);
}
//寻找以node为根的二叉搜索树的最大值
private Key maxNum(Node node) {
while(node.right!=null)
node=node.right;
return node.key;
}

10.删除二叉搜索树的最小值结点【要考虑最左子树还有右子树的情况】

public void removeMin() {
if(root!=null)
root=removeMin(root);
}
//删除以node为根的二叉搜索树的最小值，返回删除后新树的根结点【递归】
private Node removeMin(Node node) {
if(node.left==null) {
//包含了右子树为空的情况
count--;//节点数要减一
return node.right;
}
node.left=removeMin(node.left);
return node;
}

11.删除二叉搜索树的最大值结点【要考虑最右子树还有左子树的情况】

public void removeMax() {
if(root!=null)
root=removeMax(root);
}
//删除以node为根的二叉搜索树的最大值，返回新树的根结点
private Node removeMax(Node node) {
if(node.right==null) {
count--;
return node.left;
}
node.right=removeMax(node.right);
return node;
}

12.删除二叉搜索树中任意一个节点key

public void deleteNum(Key key) {
root=deleteNum(root,key);
}
//删除以node为根的二叉搜索树中，键值为key的节点
//返回删除后新二叉树的根
private Node deleteNum(Node node, Key key) {
//处理递归到底，未找到情况
if(node==null)
return null;
//在左子树中找到并删除
if(node.key.compareTo(key)>0) {
node.left=deleteNum(node.left,key);
}
//在右子树中找到并删除
else if(node.key.compareTo(key)<0) {
node.right=deleteNum(node.right, key);
}else {
//若左子树为空或者左右子树均为空
if(node.left==null) {
count--;
return node.right;
}
//若右子树为空
if(node.right==null) {
count--;
return node.left;
}
//若node的左右子树均不为空
//先找到右子树的最小值来作为要删除节点的后继
Node s1=minNum(node.right);
//新建一个节点，用来替换，以防和后面removeMin冲突
Node s=new Node(s1.key, s1.value);
count++;
//s的右子树是将s本身删除后的右子树
s.right=removeMin(node.right);
s.left=node.left;
count--;
return s;
}
return node;
}

public static void main(String args[]) {
//不能用基本类型，HashMap对象的key、value值均可为null。
BinarySearchTree<Integer,String> bTree =new BinarySearchTree<>();
//插入数据
bTree.insert(7,"A");
bTree.insert(3, "C");
bTree.insert(4,"E");
bTree.insert(11,"r");
bTree.insert(23, "t");
bTree.insert(41,"e");
//包含和查找
System.out.println(bTree.contain(44));
System.out.println(bTree.search(11));
//深度优先遍历
bTree.preOrder();
bTree.inOrder();
bTree.postOrder();
//广度优先遍历【层序遍历】
bTree.levelOrder();
//寻找最小值和最大值
System.out.println(bTree.minNum().key);
System.out.println(bTree.maxNum());
//删除最大值
bTree.removeMax();
System.out.println(bTree.maxNum());
System.out.println(bTree.size());
//删除任意一个节点
bTree.deleteNum(11);
bTree.inOrder();
}