数据结构之集合Set

1、高层的数据结构，集合Set和映射Map，什么是高层的数据结构呢，比如说是栈和队列，这种数据结构更像是先定义好了使用接口，有了这些使用接口，包括数据结构本身所维持的一些性质，可以很方便的放入到一些应用中，但是底层实现可以多种多样的，比如栈和队列，底层实现既可以是动态数据，也可以是链表。

　　集合就是承载元素的容器，集合Set中有一个重要的特性，就是每个元素在集合中只能存在一次，可以快速帮助去重工作，去重就是去除重复的元素，让所有的元素只保留一份。

2、基于二分搜索树实现的Set集合。代码，如下所示：

首先定义一个接口，然后分别使用二分搜索树的方式和链表的方式实现集合的功能。

package com.set;

/**
 * @ProjectName: dataConstruct
 * @Package: com.set
 * @ClassName: Set
 * @Author: biehl
 * @Description: ${description}
 * @Date: 2020/3/14 10:41
 * @Version: 1.0
 */
public interface Set<E> {


    /**
     * Set集合的新增
     *
     * @param e
     */
    public void add(E e);

    /**
     * 删除集合的元素
     *
     * @param e
     */
    public void remove(E e);

    /**
     * 判断是否包含某个元素
     *
     * @param e
     * @return
     */
    public boolean contains(E e);

    /**
     * 获取集合的个数
     *
     * @return
     */
    public int getSize();

    /**
     * 判断集合是否为空
     *
     * @return
     */
    public boolean isEmpty();
}

使用二分搜索树的方式实现，代码如下所示：

package com.set;

import com.tree.BinarySearchTree;

/**
 * 基于二分搜索树实现的Set集合
 *
 * @ProjectName: dataConstruct
 * @Package: com.set
 * @ClassName: BSTSet
 * @Author: biehl
 * @Description: ${description}
 * @Date: 2020/3/14 10:44
 * @Version: 1.0
 */
public class BSTSet<E extends Comparable<E>> implements Set<E> {

    // 定义二分搜索树
    private BinarySearchTree<E> binarySearchTree;

    /**
     *
     */
    public BSTSet() {
        // 无参构造函数，创建二分搜索树对象
        binarySearchTree = new BinarySearchTree<E>();
    }

    @Override
    public void add(E e) {
        // 对于重复的元素，不进行任何操作
        binarySearchTree.add(e);
    }

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

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

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

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

    public static void main(String[] args) {
        BSTSet<String> bstSet = new BSTSet<String>();
        // 集合Set的新增操作
        for (int i = 0; i < 100; i++) {
            bstSet.add(i + "");
        }

        for (int i = 0; i < bstSet.getSize(); i++) {
            System.out.println(bstSet.toString());
        }

        // 集合Set的删除操作
        bstSet.remove(0 + "");

        // 集合Set的是否包含某个元素
        boolean contains = bstSet.contains(0 + "");
        System.out.println(contains);

        // 集合Set的大小
        System.out.println(bstSet.getSize());

        // 判断集合Set是否为空
        System.out.println(bstSet.isEmpty());
    }

}

3、二分搜索树和链表都是属于动态数据结构。二分搜索树和链表的数据都是存储到Node节点中的。

package com.set;

import com.linkedlist.LinkedList;

/**
 * @ProjectName: dataConstruct
 * @Package: com.set
 * @ClassName: LinkedListSet
 * @Author: biehl
 * @Description: ${description}
 * @Date: 2020/3/14 11:54
 * @Version: 1.0
 */
public class LinkedListSet<E> implements Set<E> {

    private LinkedList<E> linkedList;

    /**
     * 无参构造函数，对linkedList进行初始化
     */
    public LinkedListSet() {
        linkedList = new LinkedList<E>();
    }

    @Override
    public void add(E e) {
        // 避免将重复的元素添加进去
        if (!linkedList.contains(e)) {
            linkedList.addFirst(e);
        }
    }

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

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

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

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

    public static void main(String[] args) {
        LinkedListSet<Integer> linkedListSet = new LinkedListSet<Integer>();
        // 基于链表实现的集合的新增
        for (int i = 0; i < 100; i++) {
            linkedListSet.add(i);
        }

        // 集合Set的删除操作
        linkedListSet.remove(0);

        // 集合Set的是否包含某个元素
        boolean contains = linkedListSet.contains(0);
        System.out.println(contains);

        // 集合Set的大小
        System.out.println(linkedListSet.getSize());

        // 判断集合Set是否为空
        System.out.println(linkedListSet.isEmpty());

    }
}

4、基于链表的集合实现的性能，慢与基于二分搜索树的集合实现。

集合Set的时间复杂度分析。

　　1）、增加add。
　　　　方式一，基于链表实现的LinkedListSet，本来在链表中添加一个元素时间复杂度是O(1)的，但是对于集合Set来说，需要去除重复元素，所以对于链表需要先查询一遍，查询的时间复杂度O(1)，所以整体上，基于LinkedListSet方式实现的的新增操作，时间复杂度是O(1)。
　　　　方式二，基于二分搜索树的实现的BSTSet，新增操作，每次新增都可以排除一半元素，因为大于根节点去右子树，小于根节点去左子树，新增操作从根节点向叶子节点出发，一层一层的向下走，经历的节点是二分搜索树的深度，新增操作、查询元素、删除元素都是这个思路，那么平均时间复杂度的是O(h)或者O(logn)，其中h是二分搜索树的深度。最差的效果是时间复杂度的是O(n)。解决这个问题可以使用平衡二叉树。

　　2)、查询contails。
　　　　方式一，基于链表实现的LinkedListSet，查询操作的时间复杂度是O(1)，因为要把所有的元素遍历。
　　　　方式二，基于二分搜索树的实现的BSTSet，那么平均时间复杂度的是O(h)或者O(logn)，其中h是二分搜索树的深度。最差的效果是时间复杂度的是O(n)。解决这个问题可以使用平衡二叉树。

　　3）、删除remove。
　　　　方式一，基于链表实现的LinkedListSet，删除操作的时间复杂度是O(1)，因为需要先找到待删除元素的前面哪一个节点，再将这个元素删除。
　　　　方式二，基于二分搜索树的实现的BSTSet，那么平均时间复杂度的是O(h)或者O(logn)，其中h是二分搜索树的深度。最差的效果是时间复杂度的是O(n)。解决这个问题可以使用平衡二叉树。
　　总结，那么n和h的比较是怎么样的呢，对于一棵满二叉树来说，如果一共有h层的话，节点个数一共是2的h次方减一个节点。那么2^h-1 = n，则h = log2(n + 1)，log以2为底的n + 1的对数。h = O(logn)，此时不管以那个数字为底的，直接简写成h = O(logn)。