# Go语言实现set

```package set

type Set interface {

Remove(e interface{})

Clear()

Contains(e interface{}) bool

Len() int

Same(other Set) bool

Elements() []interface{}

String() string

}

// 判断集合 one 是否是集合 other 的超集

func IsSuperset(one Set, other Set) bool {

if one == nil || other == nil {

return false

}

oneLen := one.Len()

otherLen := other.Len()

if oneLen == 0 || oneLen == otherLen {

return false

}

if oneLen > 0 && otherLen == 0 {

return true

}

for _, v := range other.Elements() {

if !one.Contains(v) {

return false

}

}

return true

}

// 生成集合 one 和集合 other 的并集

func Union(one Set, other Set) Set {

if one == nil || other == nil {

return nil

}

unionedSet := NewSimpleSet()

for _, v := range one.Elements() {

}

if other.Len() == 0 {

return unionedSet

}

for _, v := range other.Elements() {

}

return unionedSet

}

// 生成集合 one 和集合 other 的交集

func Intersect(one Set, other Set) Set {

if one == nil || other == nil {

return nil

}

intersectedSet := NewSimpleSet()

if other.Len() == 0 {

return intersectedSet

}

if one.Len() < other.Len() {

for _, v := range one.Elements() {

if other.Contains(v) {

}

}

} else {

for _, v := range other.Elements() {

if one.Contains(v) {

}

}

}

return intersectedSet

}

// 生成集合 one 对集合 other 的差集

func Difference(one Set, other Set) Set {

if one == nil || other == nil {

return nil

}

differencedSet := NewSimpleSet()

if other.Len() == 0 {

for _, v := range one.Elements() {

}

return differencedSet

}

for _, v := range one.Elements() {

if !other.Contains(v) {

}

}

return differencedSet

}

// 生成集合 one 和集合 other 的对称差集

func SymmetricDifference(one Set, other Set) Set {

if one == nil || other == nil {

return nil

}

diffA := Difference(one, other)

if other.Len() == 0 {

return diffA

}

diffB := Difference(other, one)

return Union(diffA, diffB)

}

func NewSimpleSet() Set {

return NewHashSet()

}

func IsSet(value interface{}) bool {

if _, ok := value.(Set); ok {

return true

}

return false

}

HashSet：

package set

import (

"bytes"

"fmt"

)

type HashSet struct {

m map[interface{}]bool

}

func NewHashSet() *HashSet {

return &HashSet{m: make(map[interface{}]bool)}

}

func (set *HashSet) Add(e interface{}) bool {

if !set.m[e] {

set.m[e] = true

return true

}

return false

}

func (set *HashSet) Remove(e interface{}) {

delete(set.m, e)

}

func (set *HashSet) Clear() {

set.m = make(map[interface{}]bool)

}

func (set *HashSet) Contains(e interface{}) bool {

return set.m[e]

}

func (set *HashSet) Len() int {

return len(set.m)

}

func (set *HashSet) Same(other Set) bool {

if other == nil {

return false

}

if set.Len() != other.Len() {

return false

}

for key := range set.m {

if !other.Contains(key) {

return false

}

}

return true

}

func (set *HashSet) Elements() []interface{} {

initialLen := len(set.m)

snapshot := make([]interface{}, initialLen)

actualLen := 0

for key := range set.m {

if actualLen < initialLen {

snapshot[actualLen] = key

} else {

snapshot = append(snapshot, key)

}

actualLen++

}

if actualLen < initialLen {

snapshot = snapshot[:actualLen]

}

return snapshot

}

func (set *HashSet) String() string {

var buf bytes.Buffer

buf.WriteString("HashSet{")

first := true

for key := range set.m {

if first {

first = false

} else {

buf.WriteString(" ")

}

buf.WriteString(fmt.Sprintf("%v", key))

}

buf.WriteString("}")

return buf.String()

}

```

1777 篇文章318 人订阅

0 条评论

## 相关文章

### 剑指Offer-从尾到头打印链表

package LinkedList; import java.util.ArrayDeque; import java.util.ArrayList; im...

3176

3377

1933

1711

### DotNet加密方式解析--非对称加密

新年新气象，也希望新年可以挣大钱。不管今年年底会不会跟去年一样，满怀抱负却又壮志未酬。（不过没事，我已为各位卜上一卦，卦象显示各位都能挣钱...）...

6908

1702

1462

924

### 剑指Offer-二叉树的镜像

package Tree; import java.util.ArrayDeque; import java.util.ArrayList; import j...

3304

### 数据结构C#版笔记--树与二叉树

图1 上图描述的数据结构就是“树”，其中最上面那个圈圈A称之为根节点(root)，其它圈圈称为节点(node)，当然root可以...

2598