JavaScript--数据结构与算法之集合

集合(Set)：是一种包含不同元素的数据结构。
    重要特性：1.集合中的成员时无序的；2.集合中不允许相同的成员存在。
    使用场景：用于存储一些独一无二的元素。
 1 集合的定义：（和高中数学中的集合一样）是有一组无序且彼此之间又有一定相关性的成员构成，每个成员只能出现一次。
 1.1基本概念：
    空集：不包含任何成员的集合。
    全集：包含一切可能成员的集合。
    两个集合相等：两个集合的成员完全相等。
    子集：一个集合中的所有成员都属于另外一个集合，前一个集合是后一个集合的子集。
  1.2 集合的基本操作：
    并集：将两个集合的成员进行合并
    交集：两个集合中共同存在的成员
    补集：属于一个集合而不属于另一个集合的成员
  2.Set类的实现：
    Set类的实现基于数组存储。

        function Set() {
            this.dataStore = [];
            /*this.add = add;
            this.remove = remove;
            this.size = size;
            this.show = show;
            this.union = union;(并集)
            this.contains = contains;
            this.intersect = intersect;(交集)
            this.subset = subset;
            this.difference = difference;*/
        }

向集合中添加成员

        Set.prototype.add = function(data) {
            if(this.dataStore.indexOf(data) <0) {//判断集合是否存在所添加的成员，indexOf检索数据如果找到成员返回该成员在数组中的位置，没找到返回-1。
                this.dataStore.push(data);
                return true;
            }else{
                return false;
            }
        };

从集合中删除成员

        Set.prototype.remove = function(data) {
            var _pos = this.dataStore.indexOf(data);//检索该成员是否存在
            if(_pos > -1) {//该成员存在
                this.dataStore.splice(_pos,1);
                return true;
            }else{
                return false;
            }
        };

显示该集合的成员信息

        Set.prototype.show = function() {
            return this.dataStore;
        };

显示该集合的成员个数

        Set.prototype.size = function() {
            return this.dataStore.length;
        };

//跑起来。。。

        var set1 = new Set();
        set1.add("Seafuwg");
        set1.add("Wunworld");
        set1.add("Assassin");
        console.log(set1.show());
        console.log(set1.size());    

2、集合的高级操作：交intersect()、并union()、差（补）difference()、子集subset();
    union()方法执行并集操作，将两个集合合并成一个集合。
    该方法首先将第一个集合的成员悉数加入一个临时集合，然后检查第二个集合的成员，看他们是否也同时属于第一个集合，如果存在，则跳过该成员，否则就将该成员加入临时集合。

并集操作，在并集定义时首先定义一个辅助方法contains(),该方法检测一个成员是否属于该集合

        Set.prototype.contains = function(data) {
            if(this.dataStore.indexOf(data) > -1) {
                return true;
            }else{
                return false;
            }
        };

并集操作

        Set.prototype.union = function(set) {
            var _tempSet = new Set();//临时集合
            for(var i = 0;i < this.dataStore.length;i++) {
                _tempSet.add(this.dataStore[i]);//添加到临时集合中
            }
            for(var i = 0; i < set.dataStore.length;i++) {//遍历集合
                if(!_tempSet.contains(set.dataStore[i])) {//检测成员是否属于该集合
                    _tempSet.dataStore.push(set.dataStore[i]);//不属于该集合的成员添加到临时集合中
                }
            }
            return _tempSet;
        };

赶快跑一把。。

        var set2 = new Set();
        set2.add("2222");
        set2.add("wunworld");
        set2.add("Wunworld");
        set2.add("Assassin");
        var newSet = new Set();
        newSet = set2.union(set1);
        console.log(newSet);    

交集intersect();的实现：

每当发现第一个集合的成员也属于第二个集合时。便将该成员加入一个新的集合。

        Set.prototype.intersect = function(set) {
            var _tempSet = new Set();
            for(var i = 0;i < this.dataStore.length;i++) {//遍历集合
                if(set.contains(this.dataStore[i])) {//判断是否有相同的成员
                    _tempSet.add(this.dataStore[i]);//相同的添加到临时集合中
                }
            }
            return _tempSet;
        };

at once running...

        var newSet2 = new Set();
        newSet2 = set1.intersect(set2);
        console.log(newSet2);

补集difference();的实现:

该方法返回一个新的集合，该集合包含的是属于第一个集合但不属于第二个集合的成员。

        Set.prototype.difference= function(set) {
            var _tempSet = new Set();
            for(var i = 0;i < this.dataStore.length;i++) {
                if(!set.contains(this.dataStore[i])) {
                    _tempSet.add(this.dataStore[i]);
                }
            }
            return _tempSet;
        };

//Running...

        var set3 = new Set();
        var set4 = new Set();
        set3.add("Wunworld");
        set3.add("Assassin");
        set3.add("Seafuwg");
        set4.add("Seafuwg");
        set4.add("Assassin");
        set4.add("2112313");
        var diff = new Set();
        diff = set3.difference(set4);
        console.log(diff);

//  Wunworld

子集subset();的实现：

该方法首先要确定该集合的长度要小于要比较的集合的长度。再判断该集合内的成员是否都属于待比较集合。如果有任意一个成员不属于待比较集合，返回false。如果一直比较完该集合的最后一个元素都属于待比较集合，则该集合就是待比较集合的一个子集，返回true。

        Set.prototype.subset = function(set) {
            /*if(this.size() > set.size()) {
                return false;
            }else{
                for(var member in this.dataStore) {
                    if(!set.contains(member)) {
                        return false;
                    }
                }
                return true;
            }*/
            if(this.size() > set.size()) {
                return false;
            }else{
                return this.dataStore.every(function (item) {
                    //every() 方法用于检测数组所有元素是否都符合指定条件（通过函数提供)
                    //如果数组中检测到有一个元素不满足，则整个表达式返回 false ，且剩余的元素不会再进行检测。
                    //如果所有元素都满足条件，则返回 true。
                    return set.dataStore.indexOf(item)>-1
                });
            }
        };

//running..

        var set5 = new Set();
        set5.add("Assassin");
        console.log(set5.subset(set4));

//true...
=====================================

完整实现：

        function Set() {
            this.dataStore = [];
            /*this.add = add;
            this.remove = remove;
            this.size = size;
            this.show = show;
            this.union = union;(并集)
            this.contains = contains;
            this.intersect = intersect;(交集)
            this.subset = subset;
            this.difference = difference;*/
        }
        Set.prototype = {
            add : function(data) {
                if(this.dataStore.indexOf(data) <0) {//判断集合是否存在所添加的成员，indexOf检索数据如果找到成员返回该成员在数组中的位置，没找到返回-1。
                    this.dataStore.push(data);
                    return true;
                }else{
                    return false;
                }
            },
            remove:function(data) {
                var _pos = this.dataStore.indexOf(data);//检索该成员是否存在
                if(_pos > -1) {//该成员存在
                    this.dataStore.splice(_pos,1);
                    return true;
                }else{
                    return false;
                }
            },
            show:function() {
                return this.dataStore;
            },
            size:function() {
                return this.dataStore.length;
            },
            contains:function(data) {
                if(this.dataStore.indexOf(data) > -1) {
                    return true;
                }else{
                    return false;
                }
            },
            union:function(set) {
                var _tempSet = new Set();//临时集合
                for(var i = 0;i < this.dataStore.length;i++) {
                    _tempSet.add(this.dataStore[i]);//添加到临时集合中
                }
                for(var i = 0; i < set.dataStore.length;i++) {//遍历集合
                    if(!_tempSet.contains(set.dataStore[i])) {//检测成员是否属于该集合
                        _tempSet.dataStore.push(set.dataStore[i]);//不属于该集合的成员添加到临时集合中
                    }
                }
                return _tempSet;
            },
            intersect:function(set) {
                var _tempSet = new Set();
                for(var i = 0;i < this.dataStore.length;i++) {//遍历集合
                    if(set.contains(this.dataStore[i])) {//判断是否有相同的成员
                         _tempSet.add(this.dataStore[i]);//相同的添加到临时集合中
                       }
                }
                return _tempSet;
             },
             difference:function(set) {
                var _tempSet = new Set();
                for(var i = 0;i < this.dataStore.length;i++) {
                    if(!set.contains(this.dataStore[i])) {
                         _tempSet.add(this.dataStore[i]);
                    }
                }
                return _tempSet;
             }
        };