數據結構之集合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)。