Java —— 手动实现基于二分搜索树的集合

具体实现

手写实现Set集合感觉挺复杂的，但是在看过底层源码以及相关视频后就有了一些思路：

1. 定义一个Set接口，这个接口中包含了要使用的方法
2. 编写二分搜索树类，这个类里面就是Set接口里面的方法
3. 实现二分搜索树集合类，主要是@Override二分搜索树中的方法

步骤对应代码如下：

一、Set接口

public interface Set<E> {
    /**
     * 除非实现接口的类是抽象类，否则该类要定义接口中的所有方法。
     * 接口并不是类； 接口包含类要实现的方法。
     * 一个类通过实现接口的方式，从而来实现接口的抽象方法。
     * 接口中的方法是不能在接口中实现的，只能由实现接口的类来实现接口中的方法。
     * @param e
     */

    void add(E e);

    void remove(E e);

    boolean contains(E e);

    int getSize();

    boolean isEmpty();

}

二、二分搜索树

import java.util.LinkedList;
import java.util.Queue;
import java.util.Stack;

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;
            left = null;
            right = null;
        }
    }

    private Node root;
    private int size;

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

    //增添,删除的时候要进行维护，即size ++; size--;
    public int size(){
        return size;
    }

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

    //向二分搜索树中添加新的结点
    public void add(E e){
        if(root == null) {
            root = new Node(e);
            size++;
        }
        //当根不为空的时候尝试从根节点开始插入新的元素
        else
            //注意这个add是private
            add(root, e);
    }
    //在上面方法的基础上，向以node为根的二分搜索树中插入元素E，（递归）
    private void add(Node node, E e){  //因为根是在不断变化的,node代表当前结点

        //递归终止条件
        if(e.equals(node.e)) //要插入的元素在二分搜索树中已经有了
            return;
        else if(e.compareTo(node.e) < 0 && node.left == null){
            node.left = new Node(e);    //把要加入的元素放进此空间
            size ++;
            return;
        }
        else if(e.compareTo(node.e) > 0 && node.right == null){
            node.right = new Node(e);   //左小<  右大>
            size ++;
            return;
        }

        //开始递归比较进行插入；
        //且要插入的元素就是在空的地方的
        if(e.compareTo(node.e) < 0)
            add(node.left, e);
        else
            add(node.right, e);
    }


    //看当前树中是否包含元素e
    public boolean contains(E e){
        return contains(root, e);
    }

    //在上面方法的基础上，向以node为根的二分搜索树中查询元素E，（私有，递归）
    private boolean contains(Node node, E e){

        if(node == null)
            return false;

        if(e.compareTo(node.e) == 0)
            return true;
        else if(e.compareTo(node.e) < 0)
            return contains(node.left, e);
        else if(e.compareTo(node.e) > 0)
            return contains(node.right, e);
        else{
            return false;
        }
    }

    //非递归的前序遍历,(栈中的是结点，既然有结点那就有Node类)
    public void preOrderNR(){
        Stack<Node> stack = new Stack<Node>();
        stack.push(root);

        while(!stack.isEmpty()){
            //cur就是当前要访问的结点，弹出，并输出
            Node cur = stack.pop();
            System.out.println(cur.e);

            //在访问完cur结点后就去访问它对应的左右子树，并压入
            if(cur.left != null)
                stack.push(cur.left);
            if(cur.right != null)
                stack.push(cur.right);
        }
    }

    //层序遍历(队列）
    public void levelOrder(){
        /**
         * 这种是错误的，因为Queue是个接口,不能直接被实例化
         * Queue<Node> queue = new Queue<>();
         */
        Queue<Node> queue = new LinkedList<>();
        queue.add(root);
        while(!queue.isEmpty()){
            Node cur = queue.remove();
            System.out.println(cur.e);

            if(cur.left != null)
                queue.add(cur.left);
            if(cur.right != null)
                queue.add(cur.right);
        }
    }

    //寻找二分搜索树的最小结点（最大结点同理）
    public E minmum(){
        if(size == 0)
            throw new IllegalArgumentException("empty");
        return minmum(root).e;
    }

    private Node minmum(Node node){
        if(node.left == null)
            return node;
        return minmum(node.left);
    }


    //删除二分搜索树的最小结点,并返回最小值
    public E removeMin(){
        E ret = minmum();  //提前保存返回这个最小的元素
        removeMin(root);
        return ret;
    }
    private Node removeMin(Node node){
        if(node.left == null){  //这个node就是要删的结点,node.left是它的左子树
            Node rightNode;  //rightNode用来保存当前结点的右子树（如果有的话）
            rightNode = node.right;
            node.right = null;
            size --;
            return rightNode;   //修改以及删除之后一定要返回新的！（这时最小节点就被删除啦）
        }

        //然后一直向左进行递归，因为最小值是一定在最左边的，且这个最小值没有左子树
        node.left = removeMin(node.left);
        return node;
    }



    //删除任意一个元素
    public void remove(E e){
        root = remove(root, e);
    }
    //删除以node为根的二分搜索树中的 值为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 if(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;
            }
            /**
             * 左右子树都不为空时
             * 先找到待删除结点右子树的最小结点，
             * 再用这个结点顶替待删除结点的位置（不需要做size--操作）
             */

            Node faitour = minmum(node.right);
            faitour.right = removeMin(node.right);
            faitour.left = node.left;
            node.left = node.right = null;
            return faitour;
        }
        else return null;
    }
}

三、实现接口中的方法

/**
 * 基于二分搜素树的集合实现
 */
public abstract class BSTSet<E extends Comparable<E>> implements Set<E> {
    //E代表二分搜索树中的元素类(型)，由于二分搜索树的特性，每个元素应是不相等的
    //所以要继承父类Comparable类，再利用implements实现父接口 完成子类定义！

    private BST<E> bst;

    public BSTSet(){
        bst = new BST<>();
    }

    @Override
    public int getSize(){
        return bst.size();
    }

    @Override
    public boolean isEmpty(){
        return bst.isEmpty();
    }

    @Override
    public void add(E e){
        bst.add(e);
    }

    @Override
    public boolean contains(E e){
        return bst.contains(e);
    }

    @Override
    public void remove(E e){
        bst.remove(e);
    }
}

上面三步完成后，即可在主方法中完成想测试的东西，比如进行数据的排序生成等等。先：

BSTSet<E> 对象名 = new BSTSet<E>();

 之后就可以用对象调用方法去实现对应的操作了！