精华内容
下载资源
问答
  • <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <meta ...meta name="viewport" content="width=device-width, initial-scale=1.0">...D.
    <!DOCTYPE html>
    <html lang="en">
    
    <head>
        <meta charset="UTF-8">
        <meta http-equiv="X-UA-Compatible" content="IE=edge">
        <meta name="viewport" content="width=device-width, initial-scale=1.0">
        <title>Document</title>
    </head>
    
    <body>
        <script>
            function Set() {
    
                this.items = {
    
                    }
                    // add方法
                Set.prototype.add = function(value) {
                    if (this.has(value)) {
                        return false
                    }
                    this.items[value] = value;
                    return true
                }
                Set.prototype.has = function(value) {
                    return this.items.hasOwnProperty(value)
                }
                Set.prototype.remove = function(value) {
                    //1.判断改元素否含有此元素
                    if (!this.has(value)) {
                        return false
                    }
                    delete this.items[value]
                    return true
                }
                Set.prototype.claer = function() {
                    this.items = {}
                }
                Set.prototype.size = function() {
                    return Object.keys(this.items).length
                }
                Set.prototype.values = function() {
                        return Object.keys(this.items)
                    }
                    //并集
                Set.prototype.union = function(otherSet) {
                        var unionset = new Set();
                        var values = this.values()
                        for (var i = 0; i < values.length; i++) {
                            unionset.add(values[i])
    
                        }
                        values = otherSet.values()
                        for (var i = 0; i < values.length; i++) {
                            unionset.add(values[i])
                        }
                        return unionset
                    }
                    //交集
                Set.prototype.interSection = function(otherSet) {
                        var intersection = new Set();
                        var values = this.values()
                        for (var i = 0; i < values.length; i++) {
                            var items = values[i]
                            if (otherSet.has(items)) {
                                intersection.add(items)
                            }
                        }
    
                        return intersection
    
                    }
                    //差集
                Set.prototype.difference = function(otherSet) {
                        var differenceset = new Set();
                        var values = this.values()
                        for (var i = 0; i < values.length; i++) {
                            var items = values[i]
                            if (!otherSet.has(items)) {
                                differenceset.add(items)
                            }
                        }
    
                        return differenceset
                    }
                    //子集
                Set.prototype.sebSet = function(otherSet) {
    
                    var values = this.values()
                    for (var i = 0; i < values.length; i++) {
                        var items = values[i]
                        if (!otherSet.has(items)) {
                            return false;
                        }
                    }
    
                    return true
                }
            }
            var set1 = new Set()
            set1.add('sds')
            set1.add('sds')
            set1.add('sas')
            set1.add('ss')
            console.log(set1)
            set1.remove('ss')
            console.log(set1.size())
            var set2 = new Set()
            set2.add('sds')
            set2.add('s1ds')
            set2.add('sa1')
            set2.add('ss1')
            unionset = set1.union(set2)
            console.log(unionset.values())
            console.log(set1.interSection(set2).values())
            console.log(set1.difference(set2).values())
            console.log(set1.sebSet(set2))
        </script>
    </body>
    
    </html>

    展开全文
  • 概念 1.子集、超集 如果集合A的任意一个元素都是集合B的元素,那么集合A称为集合B的子集,集合B称为集合A的超...4.差集 所有属于集合A不属于集合B的元素,和所有属于集合B且不属于集合A的元素,组成的集合称为AB的差...

    概念

    1.子集、超集

    如果集合A的任意一个元素都是集合B的元素,那么集合A称为集合B的子集,集合B称为集合A的超集。

    2.并集

    给定两个集合A,B,把他们所有的元素合并在一起组成的集合,叫做集合A与集合B的并集。

    3.交集

    所有属于集合A且属于集合B的元素所组成的集合,叫做集合A与集合B的交集

    4.差集

    所有属于集合A不属于集合B的元素,和所有属于集合B且不属于集合A的元素,组成的集合称为AB的差集

    5.集合A相对集合B的差

    集合A中所有不在集合B中的元素,称为A相对B的差

    格式

    子集 issubset()
    超集 issuperset()
    并集 |
    交集 &
    差集 ^
    相对差 -

    举例

    a = {1, 2, 3, 4, 5, 6}
    b = {4, 5, 6, 7, 8, 9}
    c = {1, 2, 3}
    print(c.issubset(a))  # 判断c是a的子集,结果为True
    print(a.issuperset(c))  # 判断a是c的超集,结果为True
    print(a | b)  # 并集,结果为{1, 2, 3, 4, 5, 6, 7, 8, 9}
    print(a & b)  # 交集,结果为{4, 5, 6}
    print(a ^ b)  # 差集,结果为{1, 2, 3, 7, 8, 9}
    print(a - b)  # a相对b的差,结果为{1, 2, 3}
    
    展开全文
  • 1、增加 代码块: s = {6,7,8,9} #增加 s.add(1) print(s) s.update({5,2,3}) print(s) 示例及运行结果: 2、删除 代码块: s = {6,7,8,9} ...3、交集 代码块: s1 = {1,2,3} s2 = {2,3,4} ...

    1、增加

    代码块:

    s = {6,7,8,9}
    #增加
    s.add(1)
    print(s)
    
    s.update({5,2,3})
    print(s)
    

    示例及运行结果:
    在这里插入图片描述

    2、删除

    代码块:

    s = {6,7,8,9}
    #删除
    s.pop()
    print(s)
    
    s.remove(2)
    print(s)
    

    示例及运行结果:
    在这里插入图片描述

    3、交集

    代码块:

    s1 = {1,2,3}
    s2 = {2,3,4}
    
    #交集
    print('交集: ',s1.intersection(s2))
    print('交集: ',s1 & s2)
    

    示例及运行结果:
    在这里插入图片描述

    4、并集

    代码块:

    s1 = {1,2,3}
    s2 = {2,3,4}
    #并集
    print('并集: ',s1.union(s2))
    print('并集: ',s1 | s2)
    

    示例及运行结果:
    在这里插入图片描述

    5、差集

    代码块:

    s1 = {1,2,3}
    s2 = {2,3,4}
    #差集
    print('差集: ',s1.difference(s2)) #s1 - (s1&s2)
    print('差集: ',s2.difference(s1)) #s2 - (s1&s2)
    

    示例及运行结果:
    在这里插入图片描述

    6、对等差分

    代码块:

    s1 = {1,2,3}
    s2 = {2,3,4}
    #对等差分:并集-交集
    print('对等差分:',s2.symmetric_difference(s1))
    print('对等差分:',s1^s2)
    

    示例及运行结果:
    在这里插入图片描述

    7、超集和子集

    代码块:

    s3 = {4,5,6}
    s4 = {1,2,3}
    print(s3.issuperset(s4))
    print(s3.issubset(s4))
    print(s3.isdisjoint(s4))
    

    示例及运行结果:
    在这里插入图片描述

    展开全文
  • 交集:首先创建一个新的集合,代表两个集合的交集,遍历集合1中的所有元素,判断是否在集合2中,若在,则将该元素加入到新集合中,将最终的新集合返回。 差集:首先创建一个新的集合,代表两个集合的差集,遍历集合...

    JS数据结构(7)——集合

    1.什么是集合?

    在ES6中提出了 set 这个数据结构,这也就是我们说的集合。

    集合是由一组无序的、但不能重复的元素构成的。

    我们可以把集合看成一个特殊的数组,特殊之处在于里面的元素,没有顺序,也不能重复。
    没有顺序意味着不能通过下标值来进行访问,不能重复意味着相同的对象在集合中只会存在一份。

    2.集合类的封装

    代码思路:
    1. 在ES6中已经提出了 set 类,但是为了明确集合的内部实现机制,在这里我自己封装一个 Set 类。
    2. 在集合中,添加一个属性,用于保存之后添加到集合中的元素,我们使用Object来保存集合中的元素,因为Object的keys本身就是一个集合。
    3. 集合中常见的操作方法:
      (1)add(value):向集合添加一个新的项
      (2)remove(value):从集合移除一个值
      (3)has(value):如果该值已经在集合中存在,返回true,否则返回false
      (4)clear():移除集合中的所有项
      (5)size():返回集合所包含元素的数量
      (6)values():以数组形式返回集合中的所有值

    还有很多关于集合的相关操作,可以在这些基本操作的基础上,自己尝试做一做。

    代码实现:
    function Set () {
      // 属性
      this.items = {};
    
      // 方法
      // has(value):如果该值已经在集合中存在,返回true,否则返回false
      Set.prototype.has = function(value) {
        return this.items.hasOwnProperty(value);
      }
      // add(value):向集合添加一个新的项
      Set.prototype.add = function(value) {
        // 判断当前集合中是否已经包含该元素
        if(this.has(value))
          return false;
        // 将元素添加到集合中
        this.items[value] = value;
        return true;
      }
      // remove(value):从集合移除一个值
      Set.prototype.remove = function(value) {
        // 判断该集合中是否含有该元素
        if(!this.has(value))
          return false;
        // 将元素从集合中删除
        delete this.items[value];
        return true;
      }
      // clear():移除集合中的所有项
      Set.prototype.clear = function() {
        this.items = {};
        return true;
      }
      // size():返回集合所包含元素的数量
      Set.prototype.size = function() {
        return Object.keys(this.items).length;
      }
      // values():以数组形式返回集合中的所有值
      Set.prototype.values = function() {
        return Object.keys(this.items);
      }
    }
    
    // 测试:
    var set = new Set();
    console.log(set.add(111));	//结果为:true
    console.log(set.add(222));	//结果为:true
    console.log(set.add(333));	//结果为:true
    console.log(set.values());	//结果为:[ '111', '222', '333' ]
    console.log(set.add(111));	//结果为:false
    console.log(set.values());	//结果为:[ '111', '222', '333' ]
    console.log(set.remove(222));	//结果为:true
    console.log(set.values());	//结果为:[ '111', '333' ]
    console.log(set.has(333));	//结果为:true
    console.log(set.size());	//结果为:2
    console.log(set.clear());	//结果为:true
    console.log(set.values());	//结果为:[]
    

    3.集合间的操作

    代码思路:
    1. 并集:首先创建一个新的集合,代表两个集合的并集,遍历集合1和集合2的所有值,并添加到新集合中,将最终的新集合返回。
    2. 交集:首先创建一个新的集合,代表两个集合的交集,遍历集合1中的所有元素,判断是否在集合2中,若在,则将该元素加入到新集合中,将最终的新集合返回。
    3. 差集:首先创建一个新的集合,代表两个集合的差集,遍历集合1中的所有元素,判断是否在集合2中,若不在,则将元素添加到新集合中,将最终的新集合返回。
    4. 子集:判断集合1的长度是否大于集合2的长度,若大于,肯定不是集合2的子集。若不大于,判断集合1中的元素是否都在集合2中存在,都存在,则是集合2的子集,有一个不存在,则不是集合2的子集。
    代码实现:
    // 集合间的操作
      // 并集
      Set.prototype.union = function(otherSet) {
        // 创建新的集合
        var unionSet = new Set();
        // 将集合1的所有元素添加到新集合中
        var values1 = this.values();
        for (var i = 0; i <values1.length; i++) 
           unionSet.add(values1[i]);
        // 取出集合2的所有元素,判断是否要加入到新集合中
        var values2 = otherSet.values();
        for (var i = 0; i< values2.length; i++) 
          unionSet.add(values2[i]);
        return unionSet;
      }
      // 交集
      Set.prototype.intersection = function(otherSet) {
        // 创建新的集合
        var intersectionSet = new Set();
        // 取出集合1中的所有元素
        var values1 = this.values();
        // 判断集合1中的元素是否在集合2中
        for (var i = 0; i < values1.length; i++){
          if(otherSet.has(values1[i]))
            intersectionSet.add(values1[i]);
        }
        return intersectionSet;
      }
      // 差集
      Set.prototype.difference = function(otherSet) {
        // 创建新的集合
        var differenceSet = new Set();
        // 取出集合1中的所有元素
        var values1 = this.values();
        // 判断集合1中的元素是否在集合2中
        for(var i = 0; i < values1.length; i++){
          if(!otherSet.has(values1[i]))
            differenceSet.add(values1[i]);
        }
        return differenceSet;
      }
      // 子集
      Set.prototype.son = function(otherSet) {
        // 判断集合1长度是否比集合2长度大
        if(this.size() > otherSet.size())
          return false;
        // 取出集合1中的所有元素
        var values1 = this.values();  
        // 判断集合1中的所有元素是否在集合2中
        for (var i = 0; i < values1.length; i++){
          if(!otherSet.has(values1[i]))
            return false;
        }
        return true;
      }
    
    // 测试:
    // 测试:集合间的操作
    var set1 = new Set();
    var set2 = new Set();
    set1.add(111);
    set1.add(222);
    set1.add(333);
    set2.add(222);
    set2.add(333);
    set2.add(444);
    
    var unionSet = set1.union(set2);
    console.log(unionSet.values());       // 结果为:[ '111', '222', '333', '444' ]
    
    var intersectionSet = set1.intersection(set2);
    console.log(intersectionSet.values());      // 结果为:[ '222', '333' ]
    
    var differenceSet = set1.difference(set2);
    console.log(differenceSet.values());      // 结果为:[ '111' ]
    
    console.log(set1.son(set2));      // 结果为:false
    var set3 = new Set();
    set3.add(111);
    console.log(set3.son(set1));      // 结果为:true
    
    展开全文
  • function Set(){ this.items = {} //has方法 Set.prototype.has = function(value){ return this.items.hasOwnProperty(value) } //add方法 Set.prototype.add = function(value){ //value 如果存在 如果不...
  • python集合set,交集,并集,差集,对称差集子集和超集 x = {1, 2, 3, 4} y = {2, 4, 5, 6} # 交集(取x中与y中相同部分) print(x.intersection(y)) print(x & y) # 并集(去重合并) print(x.union(y)) print...
  • shell 文件处理 并集 交集 差集(1个是另一个的子集时候才能用) 1. 取出两个文件的并集(重复的行只保留一份) cat file1 file2 | sort | uniq 2. 取出两个文件的交集(只留下同时存在于两个文件中的文件) cat ...
  • python集合set,交集,并集,差集,对称差集子集和超集x = {1, 2, 3, 4}y = {2, 4, 5, 6}# 交集(取x中与y中相同部分)print(x.intersection(y))print(x & y)# 并集(去重合并)print(x.union(y))print(x | y)# ...
  • iOS 数组集合操作(交集,并集,差集子集) 求数组的 交集,并集,差集 NSArray *array1 = @[@"1",@"2",@"3"]; NSArray *array2 = @[@"1",@"5",@"6&...
  • * Set.js /** * Created by Mch on 8/20/18. */ function Set() { this.items = {} } Set.prototype = { has: function(value) { return this.items.hasOwnProperty(value); ... add: f...
  • } //交集 static differenceSet(set1, set2) { let set = new MySet(); set1.setValues().forEach(element => { if (!set2.hasOwn(element)) { set.add(element); } }); return set; } //差集 static intersection...

空空如也

空空如也

1 2 3 4 5 ... 12
收藏数 224
精华内容 89
关键字:

交集子集差集