数据结构(JS实现)——了解Set集合机制

文章目录

  • 一.set 集合的特点
  • 一.set 集合的封装
  • 三. 常见的操作
    • 3.1.add(value):添加元素
    • 3.2.remove(value):移除某个元素
    • 3.3.has(value):判断value是否在集合中
    • 3.4.clear():清空
    • 3.5.size():长度
    • 3.6.values():返回包含所有元素的数组
    • 3.7.union(): 并集
    • 3.8.intersection():交集
    • 3.9.difference():差集 : 由所有属于A且不属于B的元素组成的集合
    • 3.10.child():子集
  • 四.源码

集合结构一般的实现方式为哈希表。

本篇文章的目的时为了明确集合的内部实现机制,因此自己用Object封装一个简单的Set类

一.set 集合的特点

  1. 集合通常时无序的,不能重复的元素构成
  2. 一种特殊的数组
  3. 不能通过下标值来进行访问
  4. 相同的对象只能在集合中存在一份

一.set 集合的封装

function Set() {
     
        // 保存集合的元素
        this.items={
     };
        // 操作
    }

三. 常见的操作

集合自身操作:

1.add(value):添加元素

2.remove(value):移除某个元素

3.has(value):判断value是否在集合中

4.clear():清空

5.size():长度

6.values():返回包含所有元素的数组

集合间的操作:

7.并集

8.交集

9.差集: 设A,B是两个集合,由所有属于A且不属于B的元素组成的集合

10.子集

3.1.add(value):添加元素

判断是否为空,通过object直接添加

 Set.prototype.add = function (value) {
     
            // 判断
            if (this.has(value)) {
     
                return false;
            }
            this.items[value] = value;
            return true
        }

3.2.remove(value):移除某个元素

判断集合中是否存在此元素

若没有直接delete删除

   Set.prototype.remove = function (value) {
     
            if (this.has(value)) {
     
                delete this.items[value]
                return true
            }
            return false;
        }

3.3.has(value):判断value是否在集合中

通过hasOwnProperty()对象方法判断

 Set.prototype.has = function (value) {
     
            return this.items.hasOwnProperty(value);
        }

3.4.clear():清空

 Set.prototype.clear = function (value) {
     
            this.items = {
     }
            return true;
        }

3.5.size():长度

  Set.prototype.size = function (value) {
     
            return Object.keys(this.items).length;
        }

3.6.values():返回包含所有元素的数组

  Set.prototype.values = function () {
     
            return Object.keys(this.items);
        }

3.7.union(): 并集

  Set.prototype.union = function (otherSet) {
     
            var newSet = new Set();
            var values = this.values();
            // 将this集合放入newset中
            for (var i = 0; i < values.length; i++) {
     
                newSet.add(values[i]);
            }
            var otherSetvalues = otherSet.values();
            //将other集合放入newset中
            for (var i = 0; i < otherSetvalues.length; i++) {
     
                newSet.add(otherSetvalues[i]);
            }
            return newSet;
        }

3.8.intersection():交集

   Set.prototype.intersection = function (otherSet) {
     
            var newSet = new Set();
            var values = this.values();
            // 将this集合放入newset中
            for (var i = 0; i < values.length; i++) {
     
                if (otherSet.items.hasOwnProperty(values[i])) {
     
                    newSet.add(values[i]);
                }
            }
            return newSet;
        }

3.9.difference():差集 : 由所有属于A且不属于B的元素组成的集合

    Set.prototype.difference = function (otherSet) {
     
            var newSet = new Set();
            var values = this.values();
            // 将this集合放入newset中
            for (var i = 0; i < values.length; i++) {
     
                if (!otherSet.items.hasOwnProperty(values[i])) {
     
                    newSet.add(values[i]);
                }
            }
            return newSet;
        }

3.10.child():子集

 Set.prototype.child = function (otherSet) {
     
            if (this.size()>otherSet.size()) {
     
                return false;
            }
            var newSet = new Set();
            var values = this.values();
            // 将this集合放入newset中
            for (var i = 0; i < values.length; i++) {
     
                if (!otherSet.items.hasOwnProperty(values[i])) {
     
                    return false;
                }
            }
            return true;
        }

四.源码

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>

<body>

</body>
<script>
    function Set() {
     
        // 保存集合的元素
        this.items = {
     };

        // 操作

        // 1.add(value): 添加元素
        Set.prototype.add = function (value) {
     
            // 判断
            if (this.has(value)) {
     
                return false;
            }
            this.items[value] = value;
            return true
        }

        // 2.remove(value): 移除某个元素
        Set.prototype.remove = function (value) {
     
            if (this.has(value)) {
     
                delete this.items[value]
                return true
            }
            return false;
        }
        // 3.has(value): 判断value是否在集合中
        Set.prototype.has = function (value) {
     
            return this.items.hasOwnProperty(value);
        }

        // 4.clear(): 清空
        Set.prototype.clear = function (value) {
     
            this.items = {
     }
            return true;
        }

        // 5.size(): 长度
        Set.prototype.size = function (value) {
     
            return Object.keys(this.items).length;
        }
        // 6.values(): 返回包含所有元素的数组
        Set.prototype.values = function () {
     
            return Object.keys(this.items);
        }

        // 7.并集
        Set.prototype.union = function (otherSet) {
     
            var newSet = new Set();
            var values = this.values();
            // 将this集合放入newset中
            for (var i = 0; i < values.length; i++) {
     
                newSet.add(values[i]);
            }
            var otherSetvalues = otherSet.values();
            //将other集合放入newset中
            for (var i = 0; i < otherSetvalues.length; i++) {
     
                newSet.add(otherSetvalues[i]);
            }
            return newSet;
        }

        // 8.交集

        // 7.并集
        Set.prototype.intersection = function (otherSet) {
     
            var newSet = new Set();
            var values = this.values();
            // 将this集合放入newset中
            for (var i = 0; i < values.length; i++) {
     
                if (otherSet.items.hasOwnProperty(values[i])) {
     
                    newSet.add(values[i]);
                }
            }
            return newSet;
        }

        // 9.差集

        Set.prototype.difference = function (otherSet) {
     
            var newSet = new Set();
            var values = this.values();
            // 将this集合放入newset中
            for (var i = 0; i < values.length; i++) {
     
                if (!otherSet.items.hasOwnProperty(values[i])) {
     
                    newSet.add(values[i]);
                }
            }
            return newSet;
        }
        // 10.子集
        Set.prototype.child = function (otherSet) {
     
            if (this.size()>otherSet.size()) {
     
                return false;
            }
            var newSet = new Set();
            var values = this.values();
            // 将this集合放入newset中
            for (var i = 0; i < values.length; i++) {
     
                if (!otherSet.items.hasOwnProperty(values[i])) {
     
                    return false;
                }
            }
            return true;
        }
    }
</script>

</html>

你可能感兴趣的:(数据结构,数据结构,javascript,集合)