在Go语言中实现泛型算法：基于接口的策略

package main

import (
    "fmt"
    "sort"
)

// algoContainer 接口定义了通用算法所需的所有能力
// 它嵌入了 sort.Interface，并额外增加了 Copy 方法
type algoContainer interface {
    sort.Interface // 包含 Len(), Swap(i, j int), Less(i, j int)
    Copy() algoContainer
}

// sortableString 是一个 []byte 的别名，用于实现 algoContainer 接口
type sortableString []byte

// Len 返回字符串的长度
func (s sortableString) Len() int { return len(s) }

// Swap 交换字符串中指定索引的字符
func (s sortableString) Swap(i, j int) { s[i], s[j] = s[j], s[i] }

// Less 比较指定索引的字符大小
func (s sortableString) Less(i, j int) bool { return s[i] < s[j] }

// Copy 创建当前 sortableString 的一个副本
func (s sortableString) Copy() algoContainer {
    // 使用 append 技巧创建并返回一个新切片作为副本
    return append(sortableString{}, s...)
}

// String 方法用于 fmt.Println 方便打印
func (s sortableString) String() string { return string(s) }

// sortable3Ints 是一个固定大小的整数数组，用于实现 algoContainer 接口
type sortable3Ints [3]int

// Len 返回数组的长度
func (sortable3Ints) Len() int { return 3 } // 数组长度固定为3

// Swap 交换数组中指定索引的元素
// 注意：必须使用指针接收者来修改原始数组
func (s *sortable3Ints) Swap(i, j int) {
    (*s)[i], (*s)[j] = (*s)[j], (*s)[i]
}

// Less 比较指定索引的元素大小
func (s sortable3Ints) Less(i, j int) bool { return s[i] < s[j] }

// Copy 创建当前 sortable3Ints 的一个副本
func (s sortable3Ints) Copy() algoContainer {
    c := s // 数组是值类型，直接赋值即可创建副本
    return &c // 返回副本的地址，因为Algo函数期望操作指针
}

// Algo 是一个泛型算法，它接收一个 algoContainer 接口类型的参数
func Algo(list algoContainer) chan algoContainer {
    n := list.Len()
    out := make(chan algoContainer) // 创建一个通道用于返回结果

    go func() {
        defer close(out) // 确保通道在协程结束时关闭

        // 在这个简化的例子中，我们只执行一次迭代，
        // 但实际的算法可能会有更复杂的循环或逻辑
        for i := 0; i < n; i++ {
            // 创建数据的副本，以避免修改原始数据
            result := list.Copy()

            // 实际有用的算法逻辑：如果最后一个元素小于第一个元素，则交换它们
            // 注意：这里使用 Less(n-1, 0) 来检查最后一个元素是否小于第一个元素
            // 对应于 result[n-1] < result[0]
            if result.Less(n-1, 0) {
                result.Swap(n-1, 0)
            }
            out <- result // 将处理后的结果发送到通道
            // 在原始问题中，循环是 n 次，每次都可能发送一个结果。
            // 这里为了简化，只展示一次主要的算法逻辑。
            // 如果需要模拟原始的 n 次迭代，则每次迭代都应基于原始 list 的副本进行操作。
            break // 示例算法只运行一次，然后退出
        }
    }()
    return out // 返回结果通道
}

func main() {
    // 处理字符串
    s1 := sortableString("abc")
    c1 := Algo(s1) // 将 sortableString 传递给 Algo
    fmt.Printf("Original: %s, Processed: %s\n", s1, <-c1) // 从通道接收结果并打印

    // 处理整数数组
    s2 := sortable3Ints([3]int{1, 2, 3})
    c2 := Algo(&s2) // 将 sortable3Ints 的地址传递给 Algo (因为 Swap 需要指针接收者)
    fmt.Printf("Original: %v, Processed: %v\n", s2, <-c2) // 从通道接收结果并打印
}

Original: abc, Processed: cba
Original: [1 2 3], Processed: [3 2 1]