Java构建二分搜索树

定义

• 二分搜索树是二叉树
• 二分搜索树每个节点的值：
  • 大于其左子树所有节点的值
  • 小于其右子树所有节点的值
• 每一棵子树也是二分搜索树
• 如果是自定义的元素，存储的元素必须有可比较性

代码构建

基本

这里extends Comparable是因为泛型本身不能像数字一样做比较，因此通过e.compareTo(E e)的方法来实现二分搜索树的可比较性。

public class BST<E extends Comparable<E>> {
    private class Node {
        public E e;
        public Node left;
        public Node right;

        public Node(E e) {
            this.e = e;
            this.left = null;
            this.right = null;
        }

        public Node() {
            this(null);

        }
    }

    private Node root;
    private int size;

    public BST() {
        root = null;
        size = 0;
    }

    public int getSize() {
        return size;
    }

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

添加节点

通过递归，如果添加的值小于根节点，则进入左子树；如果添加的值大于根节点，则进入右子树；如果等于的话，则什么都不做。当递归到最后一层时，将会发现一个空节点，此时将添加的值输入进空节点，并返回当前根节点。根节点一层一层返回，最后得到整棵树的根节点。

 public void add(E e) {
        root = addNode(root, e);
    }

//向根为node的节点中添加节点，递归算法
//返回添加完节点后该二分搜索树的根节点
private Node addNode(Node node, E e) {
    if (node == null) {
        size++;
        return new Node(e);
    }
    if (e.compareTo(node.e) < 0) {
        node.left = addNode(node.left, e);
    } else if (e.compareTo(node.e) > 0) {
        node.right = addNode(node.right, e);
    }

    return node;
}

查询元素

二分搜索树没有索引的概念，因此不需要按照索引去查找元素。在这里我仍然使用递归的方式，如果寻找到了节点，则返回true；如果比现节点小，则进入左子树；如果比现节点大，则进入右子树。如果整个树遍历到空节点都没有找到相等的元素，则返回false。

//查询树中是否有元素e
public boolean contains(E e) {
    return contains(root, e);
}
//查询根节点为root的树中是否包含e，递归
private boolean contains(Node node, E e) {
    if (node.e == null) {
        return false;
    }
    if (e.compareTo(node.e) == 0) {
        return true;
    } else if (e.compareTo(node.e) < 0) {
        return contains(node.left, e);
    } else {
        return contains(node.right, e);
    }
}

前序遍历

前序遍历 + 输出

//前序遍历
public void preOrder() {
    preOrder(root);
}
//前序遍历根节点为node的树
private void preOrder(Node node) {
    if (node == null) {
        return;
    }
    System.out.println(node.e);
    preOrder(node.left);
    preOrder(node.right);
}

@Override
public String toString() {
    StringBuilder res = new StringBuilder();
    generateBTSString(root, 0, res);
    return res.toString();
}

//前序遍历输出
private void generateBTSString(Node node, int depth, StringBuilder res) {
    if (node == null) {
        res.append(generateDepthString(depth) + "null\n");
        return;
    }
    res.append(generateDepthString(depth) + node.e + "\n");
    generateBTSString(node.left, depth + 1, res);
    generateBTSString(node.right, depth + 1, res);
}

private String generateDepthString(int depth) {
    StringBuilder res = new StringBuilder();
    for (int i = 0; i < depth; i++) {
        res.append("--");
    }
    return res.toString();
}

中序遍历

中序遍历输出的是从小到大排序好的元素

//中序遍历
public void inOrder() {
    inOrder(root);
}

private void inOrder(Node node) {
    if (node == null) {
        return;
    }
    inOrder(node.left);
    System.out.println(node.e);
    inOrder(node.right);
}

后序遍历

可以为二分搜索树释放内存，对C++语言回收垃圾有帮助

//后序遍历
public void postOrder() {
    postOrder(root);
}

private void postOrder(Node node) {
    if (node == null) {
        return;
    }
    postOrder(node.left);
    postOrder(node.right);
    System.out.println(node.e);
}

三种遍历虽然输出不一样，但是递归方式是相同的，都是从一颗树顶逆时针旋转回来。

前序遍历的非递归写法

使用堆栈技术。每次访问节点时输出该节点，并依次压入右边子节点和左边子节点。紧接着出栈并如上继续操作。

public void preOrder(){
    Stack<Node> stack = new Stack<>();
    stack.push(root);
    while(!stack.isEmpty()){
        Node cur = stack.pop();
        System.out.println(cur.e);
        if(cur.right != null)
            stack.push(cur.right);
        if(cur.left != null)
            stack.push(cur.left);
    }
}

层序遍历

层序（广度优先）遍历一般不采用递归的方式，需要用到队列的数据结构。
根节点首先入队，出队，紧接着入队左1、右1，然后出队左1，入队它的左右孩子，然后出队右1，入队它的左右孩子，依此循环至叶节点。
广度优先遍历优点在于可以更快找到问题的解，常用于算法设计中——无权图最短路径。

//层序遍历
public void levelTraverse() {
    Queue<Node> queue = new LinkedList<>();
    queue.add(root);
    while (!queue.isEmpty()) {
        Node node = queue.remove();
        System.out.println(node.e);
        if (node.left != null) {
            queue.add(node.left);
        }
        if (node.right != null) {
            queue.add(node.right);
        }
    }
}

需要注意，Java自带的Queue只是一个接口，实例化需要new一个它的实例化类。

删除节点

删除最小最大元素

// 寻找二分搜索树的最小元素
public E minimum(){
    if(size == 0)
        throw new IllegalArgumentException("BST is empty");

    Node minNode = minimum(root);
    return minNode.e;
}

// 返回以node为根的二分搜索树的最小值所在的节点
private Node minimum(Node node){
    if( node.left == null )
        return node;

    return minimum(node.left);
}
// 寻找二分搜索树的最大元素
public E maximum(){
    if(size == 0)
        throw new IllegalArgumentException("BST is empty");

    return maximum(root).e;
}

// 返回以node为根的二分搜索树的最大值所在的节点
private Node maximum(Node node){
    if( node.right == null )
        return node;

    return maximum(node.right);
}
// 从二分搜索树中删除最小值所在节点, 返回最小值
public E removeMin(){
    E ret = minimum();
    root = removeMin(root);
    return ret;
}
// 删除掉以node为根的二分搜索树中的最小节点
// 返回删除节点后新的二分搜索树的根
private Node removeMin(Node node){

    if(node.left == null){
        Node rightNode = node.right;
        node.right = null;
        size --;
        return rightNode;
    }

    node.left = removeMin(node.left);
    return node;
}

// 从二分搜索树中删除最大值所在节点
public E removeMax(){
    E ret = maximum();
    root = removeMax(root);
    return ret;
}

// 删除掉以node为根的二分搜索树中的最大节点
// 返回删除节点后新的二分搜索树的根
private Node removeMax(Node node){

    if(node.right == null){
        Node leftNode = node.left;
        node.left = null;
        size --;
        return leftNode;
    }

    node.right = removeMax(node.right);
    return node;
}

删除任意节点

当需要删除左右都有孩子的节点时，只需要找到该节点右子树中与该节点数字最接近的节点（d的后继），删除它并用它来代替被删除的节点。

 public void remove(E e) {
    root = remove(root, e);
}

//删除某节点并返回根节点
private Node remove(Node node, E e) {
    if (node == null) {
        return null;
    }
    if (e.compareTo(node.e) < 0) {
        node.left = remove(node.left, e);
        return node;
    } else if (e.compareTo(node.e) > 0) {
        node.right = remove(node.right, e);
        return node;
    } else { //e.compareTo(node.e) == 0
        if (node.left == null) {
            Node rightNode = node.right;
            node.right = null;
            size--;
            return rightNode;
        }
        if (node.right == null) {
            Node leftNode = node.left;
            node.left = null;
            size--;
            return leftNode;
        }
        Node successor = minimum(node.right);
        successor.right = removeMin(node.right);
        successor.left = node.left;
        node.left = node.right = null;
        return successor;
    }
}