Go语言容器类型：深入理解Contains方法的缺失与高效成员检测策略

package main

import (
    "container/list"
    "fmt"
)

// CheckSliceContains 检查切片中是否包含某个元素
func CheckSliceContains[T comparable](slice []T, item T) bool {
    for _, v := range slice {
        if v == item {
            return true
        }
    }
    return false
}

// CheckListContains 检查list.List中是否包含某个元素
// 注意：对于list.List，由于其存储的是interface{}，需要进行类型断言和手动比较
func CheckListContains(l *list.List, item interface{}) bool {
    for e := l.Front(); e != nil; e = e.Next() {
        // 这里需要根据item的实际类型进行比较，例如如果item是int
        // 更好的做法是让调用者传入一个比较函数，或者使用泛型（Go 1.18+）
        if e.Value == item { // 简单比较，对于复杂类型可能需要自定义比较逻辑
            return true
        }
    }
    return false
}

func main() {
    // 切片示例
    nums := []int{1, 2, 3, 4, 5}
    fmt.Printf("切片 %v 包含 3: %v\n", nums, CheckSliceContains(nums, 3)) // true
    fmt.Printf("切片 %v 包含 6: %v\n", nums, CheckSliceContains(nums, 6)) // false

    // list.List 示例
    myList := list.New()
    myList.PushBack(10)
    myList.PushBack("hello")
    myList.PushBack(20)

    fmt.Printf("列表 %v 包含 'hello': %v\n", myList, CheckListContains(myList, "hello")) // true
    fmt.Printf("列表 %v 包含 30: %v\n", myList, CheckListContains(myList, 30))       // false
}

package main

import "fmt"

// IntSet 是一个基于map的整数集合
type IntSet map[int]struct{}

// Add 向集合中添加元素
func (s IntSet) Add(item int) {
    s[item] = struct{}{}
}

// Contains 检查集合中是否包含某个元素
func (s IntSet) Contains(item int) bool {
    _, found := s[item]
    return found
}

// Remove 从集合中移除元素
func (s IntSet) Remove(item int) {
    delete(s, item)
}

func main() {
    mySet := make(IntSet)
    mySet.Add(1)
    mySet.Add(2)
    mySet.Add(3)

    fmt.Printf("集合 %v 包含 2: %v\n", mySet, mySet.Contains(2)) // true
    fmt.Printf("集合 %v 包含 4: %v\n", mySet, mySet.Contains(4)) // false

    mySet.Remove(2)
    fmt.Printf("移除 2 后，集合 %v 包含 2: %v\n", mySet, mySet.Contains(2)) // false

    // 泛型版本的Set (Go 1.18+)
    type Set[T comparable] map[T]struct{}

    func (s Set[T]) Add(item T) {
        s[item] = struct{}{}
    }

    func (s Set[T]) Contains(item T) bool {
        _, found := s[item]
        return found
    }

    stringSet := make(Set[string])
    stringSet.Add("apple")
    stringSet.Add("banana")
    fmt.Printf("字符串集合包含 'apple': %v\n", stringSet.Contains("apple")) // true
}

package main

import "fmt"

type User struct {
    ID   int
    Name string
}

type UserList []User

// ContainsByID 检查UserList中是否包含指定ID的用户
func (ul UserList) ContainsByID(id int) bool {
    for _, user := range ul {
        if user.ID == id {
            return true
        }
    }
    return false
}

func main() {
    users := UserList{
        {ID: 1, Name: "Alice"},
        {ID: 2, Name: "Bob"},
        {ID: 3, Name: "Charlie"},
    }

    fmt.Printf("用户列表中包含ID为2的用户: %v\n", users.ContainsByID(2)) // true
    fmt.Printf("用户列表中包含ID为4的用户: %v\n", users.ContainsByID(4)) // false
}

// 假设你已经导入了 goskiplist
// import "github.com/ryszard/goskiplist"

// func main() {
//     // 创建一个跳表Set
//     // 需要提供一个比较函数
//     mySet := goskiplist.New(goskiplist.IntComparator) // 假设我们存储int类型

//     mySet.Set(1, nil) // Set方法会将键1添加到Set中，值可以为nil或任意interface{}
//     mySet.Set(5, nil)
//     mySet.Set(3, nil)

//     fmt.Printf("跳表Set包含 3: %v\n", mySet.Contains(3)) // true
//     fmt.Printf("跳表Set包含 4: %v\n", mySet.Contains(4)) // false
// }