Go语言中实现泛型排序链表：基于接口与类型断言的策略

package linkedlist

// Comparable 接口定义了元素之间的比较能力
// 任何实现了此接口的类型都可以被排序链表存储和比较
type Comparable interface {
    Less(other Comparable) bool
}

package main // 或者你也可以将其放在 linkedlist 包中

import "fmt"

// Person 结构体代表一个具有姓名和年龄的个体
type Person struct {
    Name string
    Age  int
}

// Less 方法实现了 Person 类型之间的比较逻辑
// 它根据 Age 字段来判断当前 Person 是否小于另一个 Person
func (p Person) Less(other Comparable) bool {
    // 类型断言确保 other 参数是 Person 类型
    if o, ok := other.(Person); ok {
        return p.Age < o.Age
    }
    // 如果类型不匹配，可以根据业务需求返回错误、panic 或默认值
    // 这里简单处理，认为不同类型不可比较，或者当前元素不小于对方
    return false
}

// 为了方便打印，可以添加一个 String 方法
func (p Person) String() string {
    return fmt.Sprintf("{Name: %s, Age: %d}", p.Name, p.Age)
}

package linkedlist

// Node 代表链表中的一个节点
type Node struct {
    Value Comparable // 存储 Comparable 接口类型的值
    Next  *Node
}

// LinkedList 代表一个排序链表
type LinkedList struct {
    Head *Node
}

// New 创建并返回一个新的空链表
func New() *LinkedList {
    return &LinkedList{}
}

package linkedlist

// (Node, LinkedList, New 的定义如上)

// Insert 将一个 Comparable 元素按序插入到链表中
func (l *LinkedList) Insert(value Comparable) {
    newNode := &Node{Value: value}

    // 情况1: 链表为空，或新元素小于头节点，则插入到头部
    if l.Head == nil || value.Less(l.Head.Value) {
        newNode.Next = l.Head
        l.Head = newNode
        return
    }

    // 情况2: 遍历链表找到插入位置
    // current 指向当前节点，其 Next 指向下一个节点
    current := l.Head
    for current.Next != nil && current.Next.Value.Less(value) {
        current = current.Next
    }

    // 将新节点插入到 current 和 current.Next 之间
    newNode.Next = current.Next
    current.Next = newNode
}

package main

import (
    "fmt"
    "your_module_path/linkedlist" // 假设 linkedlist 包位于你的 Go 模块路径下
)

// Person 结构体和 Less 方法的实现，如前所示
type Person struct {
    Name string
    Age  int
}

func (p Person) Less(other linkedlist.Comparable) bool {
    if o, ok := other.(Person); ok {
        return p.Age < o.Age
    }
    // 考虑更健壮的错误处理，例如 panic("类型不匹配")
    return false
}

func (p Person) String() string {
    return fmt.Sprintf("{Name: %s, Age: %d}", p.Name, p.Age)
}

func main() {
    l := linkedlist.New()

    p1 := Person{Name: "Alice", Age: 30}
    p2 := Person{Name: "Bob", Age: 25}
    p3 := Person{Name: "Charlie", Age: 35}
    p4 := Person{Name: "David", Age: 28}

    l.Insert(p1)
    l.Insert(p2)
    l.Insert(p3)
    l.Insert(p4)

    // 打印链表内容以验证排序
    fmt.Println("Sorted Linked List (by Age):")
    current := l.Head
    for current != nil {
        // 再次进行类型断言以访问具体类型的字段
        if p, ok := current.Value.(Person); ok {
            fmt.Printf("%s -> ", p)
        } else {
            fmt.Printf("Unknown Type -> ")
        }
        current = current.Next
    }
    fmt.Println("nil")

    // 尝试插入其他类型（如果实现了 Comparable 接口）
    // 例如，一个整数类型
    type MyInt int
    func (mi MyInt) Less(other linkedlist.Comparable) bool {
        if oi, ok := other.(MyInt); ok {
            return mi < oi
        }
        return false
    }

    fmt.Println("\nInserting MyInts:")
    l2 := linkedlist.New()
    l2.Insert(MyInt(50))
    l2.Insert(MyInt(20))
    l2.Insert(MyInt(80))

    current = l2.Head
    for current != nil {
        if mi, ok := current.Value.(MyInt); ok {
            fmt.Printf("%d -> ", mi)
        }
        current = current.Next
    }
    fmt.Println("nil")
}