集合（JAVA）

集合是一种元素不重复的容器

/**
 * 集合的主要特点：元素不重复
 * @param <E>
 */
public interface Set<E> {

    /**
     * 添加
     * @param e
     */
    void add(E e);

    /**
     * 判断是否存在
     * @param e
     * @return
     */
    boolean contains(E e);

    /**
     * 删除
     * @param e
     */
    void remove(E e);

    /**
     * 元素个数
     * @return
     */
    int getSize();

    /**
     * 是否为空
     * @return
     */
    boolean isEmpty();

}

基于二分搜索树的集合

/**
 * 基于二分搜索树的集合
 * @param <E>
 */
public class BSTSet<E extends Comparable<E>> implements Set<E> {

    private BST<E> bst;

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

    @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);
    }

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

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

}

需要特别注意：这里使用的二分搜索树相应的也是去重的，而且因为二分搜索树需要元素具有可比较性，相应的集合元素也应具有该性质。

基于链表的集合

import java.util.LinkedList;

public class LinkedSet<E> implements Set<E> {

    private LinkedList<E> linkedList;

    public LinkedSet() {
        linkedList = new LinkedList<>();
    }

    @Override
    public void add(E e) {
        if (contains(e)) {
            return;
        }
        linkedList.add(e);
    }

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

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

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

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

这里用的链表是java中的链表，也可以使用自定义的链表，需要注意的是在添加元素时需要处理重复的情况。

基于数组的集合

public class ArraySet<E> implements Set<E> {

    private E[] array;

    private int size;

    public ArraySet() {
        array = (E[]) new Object[10];
        size = 0;
    }

    @Override
    public void add(E e) {
        if (contains(e)) {
            return;
        }
        array[size++] = e;
    }

    @Override
    public boolean contains(E e) {
        return indexOf(e) != -1;
    }

    private int indexOf(E e) {
        for (int i = 0; i < size; i++) {
            if (array[i].equals(e)) {
                return i;
            }
        }
        return -1;
    }

    @Override
    public void remove(E e) {
        int removeIndex = indexOf(e);
        for (int i = removeIndex; i < size; i++) {
            array[i] = array[i + 1];
        }
        if (removeIndex == -1) {
            return;
        }
        size--;
    }

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

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

这里没有使用增强的数组，所以里边有一堆bug