在Go语言中通过接口实现通用算法设计

func Algo(list []interface{}) chan []interface{} {
    n := len(list)
    out := make(chan []interface{})
    go func () {
        for i := 0; i < n; i++ {
            result := make([]interface{}, n)
            copy(result, list)
            // 错误：interface{}不支持比较操作
            // if (result[0] > result[n-1]) { 
            //     result[0], result[n-1] = result[n-1], result[0]
            // }
            out <- result
        }
        close(out)
    }()
    return out
}

type Interface interface {
    // Len is the number of elements in the collection.
    Len() int
    // Less reports whether the element at index i
    // is less than the element at index j.
    Less(i, j int) bool
    // Swap exchanges the elements at index i and j.
    Swap(i, j int)
}

type algoContainer interface {
    sort.Interface // 嵌入sort.Interface，提供Len, Less, Swap能力
    Copy() 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 复制字符串，返回新的algoContainer
func (s sortableString) Copy() algoContainer {
   return append(sortableString{}, s...) // 深度复制
}

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

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 复制数组，返回新的algoContainer（返回指针以避免值复制问题）
func (s sortable3Ints) Copy() algoContainer { c := s; return &c }

package main

import (
    "fmt"
    "sort" // 引入sort包以使用sort.Interface
)

// algoContainer 接口定义了通用算法所需的能力
type algoContainer interface {
    sort.Interface
    Copy() algoContainer
}

// sortableString 实现了algoContainer接口，用于处理字符串
type sortableString []byte
func (s sortableString) Len() int { return len(s) }
func (s sortableString) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
func (s sortableString) Less(i, j int) bool { return s[i] < s[j] }
func (s sortableString) Copy() algoContainer {
   return append(sortableString{}, s...)
}
func (s sortableString) String() string { return string(s) }

// sortable3Ints 实现了algoContainer接口，用于处理固定大小的整型数组
type sortable3Ints [3]int
func (sortable3Ints) Len() int { return 3 }
func (s *sortable3Ints) Swap(i, j int) {
   (*s)[i], (*s)[j] = (*s)[j], (*i)
}
func (s sortable3Ints) Less(i, j int) bool { return s[i] < s[j] }
func (s sortable3Ints) Copy() algoContainer { c := s; return &c }

// Algo 是一个通用算法，接受algoContainer接口作为参数
func Algo(list algoContainer) chan algoContainer {
    n := list.Len()
    out := make(chan algoContainer)
    go func () {
        for i := 0; i < n; i++ {
            result := list.Copy() // 通过接口调用Copy方法获取副本
            // 实际有用的算法逻辑：如果最后一个元素小于第一个元素，则交换它们
            if result.Less(n-1, 0) { // 通过接口调用Less方法进行比较
                result.Swap(n-1, 0) // 通过接口调用Swap方法进行交换
            }
            out <- result
        }
        close(out)
    }()
    return out
}

func main() {
    // 使用sortableString调用通用算法
    s1 := sortableString("abc")
    c1 := Algo(s1)
    fmt.Printf("Original: %v, Processed: %v\n", s1, <-c1) // Output: Original: abc, Processed: cba

    // 使用sortable3Ints调用通用算法
    s2 := sortable3Ints([3]int{1,2,3})
    c2 := Algo(&s2) // 传入指针，因为Swap方法需要指针接收者
    fmt.Printf("Original: %v, Processed: %v\n", s2, <-c2) // Output: Original: [1 2 3], Processed: &[3 2 1]
}