Go语言中高效查找两个字符串切片的差集

slice1 := []string{"foo", "bar", "hello"}
slice2 := []string{"foo", "bar"}

// difference 返回在切片 'a' 中存在但不在切片 'b' 中的所有元素。
// 该函数适用于未排序的切片，并具有近似 O(n) 的时间复杂度。
func difference(a, b []string) []string {
    // 创建一个哈希映射，用于存储切片 b 中的所有元素。
    // 使用 struct{}{} 作为值可以节省内存，因为它不占用任何空间。
    mb := make(map[string]struct{}, len(b))
    for _, x := range b {
        mb[x] = struct{}{} // 将切片 b 的元素添加到映射中
    }

    var diff []string // 用于存储结果的切片

    // 遍历切片 a 中的每个元素
    for _, x := range a {
        // 检查当前元素 x 是否存在于映射 mb 中
        if _, found := mb[x]; !found {
            // 如果 x 不在 mb 中，则说明它是切片 a 独有的元素，将其添加到结果切片 diff 中
            diff = append(diff, x)
        }
    }
    return diff // 返回包含差异元素的切片
}

package main

import "fmt"

// difference 返回在切片 'a' 中存在但不在切片 'b' 中的所有元素。
// 该函数适用于未排序的切片，并具有近似 O(n) 的时间复杂度。
func difference(a, b []string) []string {
    mb := make(map[string]struct{}, len(b))
    for _, x := range b {
        mb[x] = struct{}{}
    }

    var diff []string
    for _, x := range a {
        if _, found := mb[x]; !found {
            diff = append(diff, x)
        }
    }
    return diff
}

func main() {
    slice1 := []string{"foo", "bar", "hello", "world", "foo"}
    slice2 := []string{"foo", "bar", "go"}

    result := difference(slice1, slice2)
    fmt.Printf("slice1: %v\n", slice1)
    fmt.Printf("slice2: %v\n", slice2)
    fmt.Printf("Difference (slice1 - slice2): %v\n", result) // 期望输出: ["hello" "world"]

    sliceA := []string{"apple", "banana", "cherry"}
    sliceB := []string{"banana", "date"}
    result2 := difference(sliceA, sliceB)
    fmt.Printf("Difference (sliceA - sliceB): %v\n", result2) // 期望输出: ["apple" "cherry"]
}

slice1: [foo bar hello world foo]
slice2: [foo bar go]
Difference (slice1 - slice2): [hello world]
Difference (sliceA - sliceB): [apple cherry]