我想制作一个可以包含任何类型的值的链表，但该链表必须包含任何仅一种类型的值。

一般来说，当我使用接口(interface)来实现这一点时——任何实现节点接口(interface)的类型都可以添加到链表中。

我为此编写了一个实现，每当将新键添加到链表时，都会根据头部键的类型检查键的类型。我想了解这是实现它的正确方法还是有更好的方法。

package main

import (
    "errors"
    "fmt"
    "reflect"
    "strings"
)

type MyNode struct {
    value int
}

func (node *MyNode) PrintValue() {
    fmt.Printf(" %d ", node.value)
}

type llNode struct {
    key        llNodeInterface
    next       *llNode
    llNodeType reflect.Type
}

type llNodeInterface interface {
    PrintValue()
}

type ComplexNode struct {
    realValue  int
    imageValue int
}

func (node *ComplexNode) PrintValue() {
    fmt.Printf(" %d + i%d", node.realValue, node.imageValue)
}

// Student type.
type Student struct {
    name string
    age  int
}

// Student implements the PrintValue function - thus llNodeInterface is implemented.
func (node *Student) PrintValue() {
    fmt.Printf("Name: %s | Age : %d ", node.name, node.age)
}

// Function which will check the of the new node before adding to the linked
// list. It checks the type of the new key against the type of the key in the
// head. If both are equal then it proceed else return error.
func (head *llNode) AddBeforeHeadTypeCheck(passedKey llNodeInterface) error {

    if head.key == nil {
        head.key = passedKey
        head.llNodeType = reflect.TypeOf(head.key)
    } else {
        typeOfPassedKey := reflect.TypeOf(passedKey)

        if typeOfPassedKey != head.llNodeType {
            fmt.Printf("\nUnsupported type for the type %T", passedKey)
            return errors.New("Type mistmatch")
        }

        temp := llNode{key: head.key, next: head.next}
        head.key = passedKey
        head.next = &temp
    }
    return nil
}

// Function which will not check the types and will simply add the new node to
// the linked list. Thus linked list will be able to have nodes of multiple
// types.
func (head *llNode) AddBeforeHead(passedKey llNodeInterface) {

    if head.key == nil {
        head.key = passedKey
        head.llNodeType = reflect.TypeOf(head.key)
    } else {
        temp := llNode{key: head.key, next: head.next}
        head.key = passedKey
        head.next = &temp
    }
}

func (head *llNode) Init() {
    head.key = nil
    head.next = nil
    head.llNodeType = nil

}

// Print the linked list.
func (head *llNode) DisplayLL() {

    temp := head
    fmt.Printf("\n%s", strings.Repeat("#", 80))
    fmt.Printf("\nPrinting the linked list\n")

    for {
        if temp.key == nil {
            fmt.Println("Linked list is empty")
            break
        } else {
            fmt.Printf("\n %T %v ", temp.key, temp.key)
            key := temp.key
            key.PrintValue()
            if temp.next == nil {
                break
            } else {
                temp = temp.next
            }
        }
    }
    fmt.Printf("\n%s", strings.Repeat("#", 80))
    fmt.Printf("\n\n")
}

func testWithMixedType() {
    head := llNode{}
    head.Init()

    for i := 1; i < 10; i++ {
        temp := &ComplexNode{i, i * 10}
        head.AddBeforeHeadTypeCheck(temp)
    }

    temps := &Student{"rishi", 20}
    head.AddBeforeHeadTypeCheck(temps) // Will give error.
    head.DisplayLL()
}

func testWithComplexNumber() {

    head := llNode{}
    head.Init()

    for i := 1; i < 10; i++ {
        temp := &ComplexNode{i, i * 10}
        head.AddBeforeHeadTypeCheck(temp)
    }

}

func main() {
    testWithComplexNumber()
    testWithMixedType()

}

代码运行良好 - 但我想了解是否有更好或不同的方法来执行此操作。

此外 - 当前使用反射包检查类型对性能有何影响。是否有不同的方法来实现相同的目标。

*main.Student 类型不受支持

Unsupported type for the type *main.Student
################################################################################
Printing the linked list

 *main.ComplexNode &{9 90}  9 + i90
 *main.ComplexNode &{8 80}  8 + i80
 *main.ComplexNode &{7 70}  7 + i70
 *main.ComplexNode &{6 60}  6 + i60
 *main.ComplexNode &{5 50}  5 + i50
 *main.ComplexNode &{4 40}  4 + i40
 *main.ComplexNode &{3 30}  3 + i30
 *main.ComplexNode &{2 20}  2 + i20
 *main.ComplexNode &{1 10}  1 + i10
################################################################################

最佳答案

好消息，从 Go 1.18 开始，Generics are now supported in Go .

按照问题中的示例，这里是一个使用泛型的简化 LinkedList。您可以在 the playground here 上修改它.

package main

import "fmt"

type MyNode[T any] struct {
    next  *MyNode[T]
    value T
}

type MyLinkedList[T any] struct {
    head *MyNode[T]
    tail *MyNode[T]
}

func (list *MyLinkedList[T]) Add(t T) *MyLinkedList[T] {
    // create node
    node := &MyNode[T]{nil, t}
    // if first node in list
    if list.head == nil {
        list.head = node
        list.tail = node
    } else {
        list.tail.next = node
        list.tail = list.tail.next
    }

    return list
}

func (list *MyLinkedList[T]) AddBeforeHead(t T) *MyLinkedList[T] {
    node := &MyNode[T]{nil, t}
    if list.head != nil {
        node.next = list.head
        list.head = node
    } else {
        // make head
        list.head = node
        list.tail = node
    }

    return list
}

// display the list
func DisplayList[T any](list *MyLinkedList[T]) string {
    var out string = ""
    iter := list.head
    for iter != nil {
        out += fmt.Sprintf("%v -> ", iter.value)
        iter = iter.next
    }
    return out
}

func (list *MyLinkedList[T]) Display() string {
    return DisplayList(list)
}

// for printing node value
// you could also implement Stringer
// but this is besides the point, you can ignore
func (node *MyNode[T]) String() string {
    return fmt.Sprintf("<MyNode: %v>", node.value)
}

// helper func: create list from array
func CreateLinkedList[T any](arr []T) *MyLinkedList[T] {
    list := &MyLinkedList[T]{}

    for _, v := range arr {
        list.Add(v)
    }

    return list
}

func main() {
    // create a list from array of integers
    intArr := []int{10, 20, 30, 40, 50, 60}
    list1 := CreateLinkedList(intArr)
    // create a list from array of strings
    strArr := []string{"foo", "bar", "baz", "faz"}
    list2 := CreateLinkedList(strArr)

    // test inserting at the beginning
    list2.AddBeforeHead("hello")

    fmt.Println(list1.Display())
    fmt.Println(list2.Display())
}

可以在此处找到一些涵盖泛型基础知识的官方引用资料:

• https://go.dev/doc/tutorial/generics
• https://go.dev/blog/intro-generics
• https://go.dev/tour/generics/1

关于go - 在 golang 中实现通用链表，它不允许在同一链表中使用不同类型，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/54301390/