二叉搜索树(Java实现)
二叉搜索树基本操作
求树中的结点个数 判断节点是否为空 向树中插入新结点key-value 树中是否存在key 返回树中key对应的value值 先序遍历 中序遍历 后续遍历 层序遍历 求树中key最小的结点 求树中key最大的结点 删除树中key最小的结点 删除树中key最大的结点 树中删除一个结点
代码：
/**
* @param <Key> 键的泛型
* @param <Value> 值的泛型
*/
public class BinarySearchTree<Key extends Comparable<? super Key>, Value> {
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;
}
// getters and setters
public Key getKey() {
return key;
}
public void setKey(Key key) {
this.key = key;
}
public Value getValue() {
return value;
}
public void setValue(Value value) {
this.value = value;
}
public Node getLeft() {
return left;
}
public void setLeft(Node left) {
this.left = left;
}
public Node getRight() {
return right;
}
public void setRight(Node right) {
this.right = right;
}
@Override
public String toString() {
return "Node{" +
"key=" + key +
", value=" + value +
'}';
}
}
private Node root; // 二叉搜索树的根节点
private int size; //二叉搜索树中的结点个数
//树的构造函数
public BinarySearchTree() {
this.root = null;
this.size = 0;
}
//求树中的结点个数
public int size() {
return this.size;
}
//判断节点是否为空
public boolean isEmpty() {
return this.size == 0;
}
//以node结点为根的树(子树)中插入key-value
private Node insert(Node node, Key key, Value value) {
if (node == null) {
size++;
return new Node(key, value);
} else if (node.key.compareTo(key) > 0) {
node.setLeft(insert(node.getLeft(), key, value));
} else if (node.key.compareTo(key) < 0) {
node.setRight(insert(node.getRight(), key, value));
} else { // 相等的时候
node.value = value;
}
return node;
}
//向树中插入新结点key-value
public void insert(Key key, Value value) {
root = insert(root, key, value);
}
// node结点为根的树(子树)中是否存在key
private boolean contain(Node node, Key key) {
if (node == null) {
return false;
} else if (node.key.compareTo(key) == 0) {
return true;
} else if (node.key.compareTo(key) > 0) {
return contain(node.getLeft(), key);
} else {
return contain(node.getRight(), key);
}
}
//树中是否存在key
public boolean contain(Key key) {
return contain(root, key);
}
//返回node结点为根的树(子树)中key对应的value值
private Value search(Node node, Key key) {
if (node == null) {
return null;
} else if (node.getKey().compareTo(key) == 0) {
return node.getValue();
} else if (node.getKey().compareTo(key) > 0) {
return search(node.getLeft(), key);
} else {
return search(node.getRight(), key);
}
}
//返回树中key对应的value值
public Value search(Key key) {
return search(root, key);
}
//先序遍历
private void preOrder(Node node) {
if (node == null) return;
System.out.println(node.key);
preOrder(node.getLeft());
preOrder(node.getRight());
}
//先序遍历
public void preOrder() {
preOrder(root);
}
//中序遍历
private void inOrder(Node node) {
if (node == null) return;
inOrder(node.getLeft());
System.out.println(node.getKey());
inOrder(node.getRight());
}
//中序遍历
public void inOrder() {
inOrder(root);
}
//后续遍历
private void postOrder(Node node) {
if (node == null) return;
postOrder(node.getLeft());
postOrder(node.getRight());
System.out.println(node.getKey());
}
//后续遍历
public void postOrder() {
postOrder(root);
}
//层序遍历
public void levelOrder() {
if (root == null) return;
java.util.LinkedList<Node> queue = new java.util.LinkedList<>();
queue.add(root);
while (!queue.isEmpty()) {
Node node = queue.pop();
System.out.println(node);
if (node.getLeft() != null) {
queue.add(node.getLeft());
}
if (node.getRight() != null) {
queue.add(node.getRight());
}
}
}
//以node为根的树中，key最小的结点
private Node minNode(Node node) {
if (node.getLeft() == null) return node;
return minNode(node.getLeft());
}
//树中key最小的结点
public Node minNode() {
return minNode(root);
}
//以node为根的树中，key最大的结点
private Node maxNode(Node node) {
if (node.getRight() == null) return node;
return maxNode(node.getRight());
}
//树中key最大的结点
public Node maxNode() {
return maxNode(root);
}
//删除node为根的树(子树)中key最小的结点
private Node removeMin(Node node) {
if (node == null) return null;
if (node.getLeft() == null) {
Node rightNode = node.getRight();
node.setRight(null);
size--;
return rightNode;
}
node.setLeft(removeMin(node.getLeft()));
return node;
}
//删除树中key最小的结点
public void removeMin() {
root = removeMin(root);
}
//删除node为根的树(子树)中key最大的结点
private Node removeMax(Node node) {
if (node == null) return null;
if (node.getRight() == null) {
Node leftNode = node.getLeft();
node.setLeft(null);
size--;
return leftNode;
}
node.setRight(removeMax(node.getRight()));
return node;
}
//删除树中key最大的结点
public void removeMax() {
root = removeMax(root);
}
//删除一个结点
private Node remove(Node node, Key key) {
if (node == null) return null;
if (key.compareTo(node.key) < 0) {//如果比根小，去左子树删除，然后返回根
node.setLeft(remove(node.getLeft(), key));
return node;
} else if (key.compareTo(node.key) > 0) {//如果比根大，去右子树删除，然后返回根
node.setRight(remove(node.getRight(), key));
return node;
} else { //key == node.key //如果与当点子树的根key相等
if (node.getLeft() == null) { //判断当前子树的根是否有左子树
Node rightNode = node.getRight();
node.setRight(null);
size--;
return rightNode;
} else if (node.getRight() == null) {//判断当前子树的根是否有右子树
Node leftNode = node.getLeft();
node.setLeft(null);
size--;
return leftNode;
} else { // 如果当前子树既有左子树，又有右子树
Node successor = minNode(node.getRight());//寻找后继结点，也就是右子树中最小的结点
successor = new Node(successor.getKey(), successor.getValue());//新建一个与后继结点一模一样的，为了替换
size++;//相当于添加一个结点
successor.setRight(removeMin(node.getRight()));//删除后继结点,然后连上原来的右边
successor.setLeft(node.getLeft());//连上原来的左边
node.left = node.right = null;//原来的结点已经被替换了，可以不要了。
size--;//相当于删除一个节点
return successor;//当前新的子树根就是successor
}
}
}
public void remove(Key key) {
root = remove(root, key);
}
public static void main(String[] args) {
//建立一颗二叉搜索树
BinarySearchTree<String, String> bst = new BinarySearchTree<>();
//插入数据
bst.insert("dog", "狗，一种动物");
bst.insert("password", "密码");
bst.insert("cat", "猫，一种动物");
bst.insert("cup", "杯子");
bst.insert("tom", "汤姆，《猫和老鼠》中的猫");
bst.insert("jerry", "杰瑞，《猫和老鼠》中的老鼠");
bst.insert("a", "26个英文字母中的第一个");
//search()
System.out.println(bst.search("a"));//26个英文字母中的第一个
System.out.println(bst.search("dog"));//狗，一种动物
System.out.println(bst.search("ttttt"));//null
//contain()
System.out.println(bst.contain("cup"));//true
System.out.println(bst.contain("tom"));//true
System.out.println(bst.contain("tttttt"));//false
//maxNode()
System.out.println(bst.maxNode());//Node{key=tom, value=汤姆，《猫和老鼠》中的猫}
//minNode()
System.out.println(bst.minNode());//Node{key=a, value=26个英文字母中的第一个}
//removeMax()
bst.removeMax();
System.out.println(bst.maxNode());//Node{key=password, value=密码}
//removeMin()
bst.removeMin();
System.out.println(bst.minNode());//Node{key=cat, value=猫，一种动物}
//size()
System.out.println(bst.size());//5
//levelOrder()
bst.levelOrder();
//remove();
System.out.println("--------------");
bst.remove("password");
bst.preOrder();
}
}
---------------------------------------------------------
学如不及，犹恐失之
学如不及，犹恐失之
