Intersection between golang array, difference sets, and sets, complement

Today difference set between the company needs two arrays, not down at the library, it is an independent, I hope useful to readers

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 { 
        SM [V] = to true 
    } 
} 

// remove elements 
FUNC (the Set S *) the Remove (items ... int ) { 
    s.Lock () 
    the defer s.Unlock () 
    for _, V: = Range items { 
        Delete (SM, V) 
    } 
} 

// determines whether there is an element 
FUNC (the Set S *) Has (items ... int ) BOOL { 
    s.RLock () 
    the defer s.RUnlock () 
    for _, V: = Range items {
         IF _, OK:! = SM [V]; OK {
             return  to false
        } 
    } 
    Return  to true 
} 

// number of elements 
FUNC (the Set S *) the Count () int {
     return len (SM) 
} 

// empty set 
FUNC (S * the Set) the Clear () { 
    s.Lock () 
    the defer s.Unlock () 
    SM = Map [ int ] BOOL {} 
} 

// null set Analyzing 
FUNC (the Set S *) Empty () BOOL {
     return len (SM) == 0 
} 

// unordered list 
func (s * Set) list ( ) [] int  {
    s.RLock () 
    the 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
}

Thank you, thank you!

Guess you like

Origin www.cnblogs.com/tsxylhs/p/11267326.html