zoukankan      html  css  js  c++  java
  • golang 数组之间的交集,差集,并集,补集

    今天公司需求两个数组之间的差集,类库下不下来,就独立出来了一份,希望读者有用

    package model
    
    
    import (
        "sort"
        "sync"
    )
    
    type Set struct {
        sync.RWMutex
        m map[int]bool
    }
    
    // 新建集合对象
    func New(items ...int) *Set {
        s := &Set{
            m: make(map[int]bool, len(items)),
        }
        s.Add(items...)
        return s
    }
    
    // 添加元素
    func (s *Set) Add(items ...int) {
        s.Lock()
        defer s.Unlock()
        for _, v := range items {
            s.m[v] = true
        }
    }
    
    // 删除元素
    func (s *Set) Remove(items ...int) {
        s.Lock()
        defer s.Unlock()
        for _, v := range items {
            delete(s.m, v)
        }
    }
    
    // 判断元素是否存在
    func (s *Set) Has(items ...int) bool {
        s.RLock()
        defer s.RUnlock()
        for _, v := range items {
            if _, ok := s.m[v]; !ok {
                return false
            }
        }
        return true
    }
    
    // 元素个数
    func (s *Set) Count() int {
        return len(s.m)
    }
    
    // 清空集合
    func (s *Set) Clear() {
        s.Lock()
        defer s.Unlock()
        s.m = map[int]bool{}
    }
    
    // 空集合判断
    func (s *Set) Empty() bool {
        return len(s.m) == 0
    }
    
    // 无序列表
    func (s *Set) List() []int {
        s.RLock()
        defer s.RUnlock()
        list := make([]int, 0, len(s.m))
        for item := range s.m {
            list = append(list, item)
        }
        return list
    }
    
    // 排序列表
    func (s *Set) SortList() []int {
        s.RLock()
        defer s.RUnlock()
        list := make([]int, 0, len(s.m))
        for item := range s.m {
            list = append(list, item)
        }
        sort.Ints(list)
        return list
    }
    
    // 并集
    func (s *Set) Union(sets ...*Set) *Set {
        r := New(s.List()...)
        for _, set := range sets {
            for e := range set.m {
                r.m[e] = true
            }
        }
        return r
    }
    
    // 差集
    func (s *Set) Minus(sets ...*Set) *Set {
        r := New(s.List()...)
        for _, set := range sets {
            for e := range set.m {
                if _, ok := s.m[e]; ok {
                    delete(r.m, e)
                }
            }
        }
        return r
    }
    
    // 交集
    func (s *Set) Intersect(sets ...*Set) *Set {
        r := New(s.List()...)
        for _, set := range sets {
            for e := range s.m {
                if _, ok := set.m[e]; !ok {
                    delete(r.m, e)
                }
            }
        }
        return r
    }
    
    // 补集
    func (s *Set) Complement(full *Set) *Set {
        r := New()
        for e := range full.m {
            if _, ok := s.m[e]; !ok {
                r.Add(e)
            }
        }
        return r
    }

    谢谢大家,谢谢!

  • 相关阅读:
    和菜鸟一起学产品之产品经理的自我管理能力
    和菜鸟一起学产品之产品经理的工作职责
    遗传算法解决TSP问题实现以及与最小生成树的对比
    双系统或三系统:Grub Rescue修复方法
    err:安装程序试图挂载映像 1(缺少ISO 9660图像)
    OpenCV手写数字字符识别(基于k近邻算法)
    最小生成树
    ubuntu12.04:Tomcat 7服务器:手动安装
    ubuntu12.04:jdk7:手动安装
    ubuntu12.04:Mysql数据库:手动安装
  • 原文地址:https://www.cnblogs.com/tsxylhs/p/11267326.html
Copyright © 2011-2022 走看看