数据结构（JS实现）——了解Set集合机制

最新推荐文章于 2024-05-28 18:15:33 发布

小牲口online

最新推荐文章于 2024-05-28 18:15:33 发布

阅读量944

点赞数

分类专栏：数据结构文章标签：数据结构 javascript 集合

本文链接：https://blog.csdn.net/M_Edison/article/details/113407847

版权

数据结构专栏收录该内容

8 篇文章 1 订阅

订阅专栏

文章目录

一.set 集合的特点
一.set 集合的封装
三. 常见的操作
四.源码

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

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

一.set 集合的特点

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

一.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>

小牲口online

关注

0
点赞
踩
5

收藏

觉得还不错? 一键收藏
0
评论
数据结构（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（）：子集四.源码集合
复制链接

扫一扫