【go从零单排】泛型(Generics)、链表

🌈Don't worry , just coding!
内耗与overthinking只会削弱你的精力，虚度你的光阴，每天迈出一小步，回头时发现已经走了很远。

📗概念

在Go语言中，泛型（Generics）允许你编写可以处理不同数据类型的函数和数据结构。

Go在1.18版本中引入了泛型，使得开发者能够更灵活地编写代码，减少重复。

泛型允许你定义一个函数或类型，使其能够接受任意类型的参数 ，而不需要在定义时指定具体的类型。

💻代码

基本使用

go 复制代码

package main

import "fmt"

// 定义一个泛型函数
func Print[T any](value T) {
    fmt.Println(value)
}

func main() {
    Print(123)          // 打印整数
    Print("Hello Go!")  // 打印字符串
    Print(3.14)        // 打印浮点数
}

定义泛型struct

go 复制代码

package main

import "fmt"

// 定义一个泛型结构体
type Pair[T any] struct {
    First  T
    Second T
}

func main() {
    // 创建一个整型的 Pair
    intPair := Pair[int]{First: 1, Second: 2}
    fmt.Println(intPair)

    // 创建一个字符串的 Pair
    stringPair := Pair[string]{First: "Hello", Second: "World"}
    fmt.Println(stringPair)
}

使用约束类型

go 复制代码

package main

import "fmt"

// 定义一个约束，只接受数字类型
type Number interface {
    int | int32 | int64 | float32 | float64
}

// 定义一个泛型函数
func Add[T Number](a, b T) T {
    return a + b
}

func main() {
    fmt.Println(Add(1, 2))        // 整数相加
    fmt.Println(Add(1.5, 2.5))    // 浮点数相加
}

切片、链表泛型

= = ！看不懂警告，大片注释来袭！！

go 复制代码

package main

import "fmt"

// 定义一个函数SlicesIndex，输入一个切片 s 和一个值 v，返回一个int类型
// 这里看不懂，先别急，下面我会好好解释
// S ~[]E：这里 S 是一个类型参数，表示它是一个切片类型（[]E）
// 使用了类型约束 ~，表示 S 可以是任何基于 E 的切片类型（例如 []int、[]string 等）。
// E comparable：E 是另一个类型参数，表示可以与其他值进行比较的类型（如整型、字符串等）
// comparable 是一个内置的约束，表示该类型支持相等比较。
// s S：函数的第一个参数 s 是一个切片，类型为 S。
// v E：函数的第二个参数 v 是要查找的值，类型为 E
func SlicesIndex[S ~[]E, E comparable](s S, v E) int {
	//在切片中查找值 v 的索引，找不到时返回-1
	for i := range s {
		if v == s[i] {
			return i
		}
	}
	return -1
}

// type List[T any]：定义一个名为 List 的泛型类型。
// T 是一个类型参数，any 表示 T 可以是任何类型。
type List[T any] struct {
	head, tail *element[T]
	//head 和 tail 是两个字段，分别指向链表的头部和尾部元素
	//*element[T] 表示这两个字段是指向 element[T] 类型的指针。

}

// element[T] 定义结构体类型，类型是any，数据为val 任意类型，指向下一个节点的指针next *element[T]
type element[T any] struct {
	next *element[T]
	val  T
}

// 定义函数Push ，lst 是指向链表的指针注意写法是List[T]，可以直接修改链表的内容。
// v T 是要插入链表中的值，类型为 T，即链表支持的任意类型。
func (lst *List[T]) Push(v T) {
	//判断链表的尾指针 tail 是否为 nil
	if lst.tail == nil {
		//如果链表为空，创建一个新的 element[T]，并将其值设置为 v，然后将这个新元素的内存地址赋值给链表的头指针 head
		lst.head = &element[T]{val: v}
		//将 tail 指向 head，因为此时链表中只有一个元素
		lst.tail = lst.head
	} else {
		//如果链表非空，创建一个新的 element[T]，并将其值设置为 v，然后将这个新元素链接到当前 tail 的 next 指针上。
		lst.tail.next = &element[T]{val: v}
		//更新 tail 指针，使其指向新添加的元素，保持 tail 始终指向链表的最后一个元素。
		lst.tail = lst.tail.next
	}
}

// 输入：定义函数AllElements，lst 是指向链表的指针
// 输出：返回一个 []T 类型的切片，包含链表中的所有元素。
func (lst *List[T]) AllElements() []T {
	//定义空的切片 elems，用于存储链表中的所有元素。
	var elems []T
	//for循环从链表的头部开始遍历。
	//e 是当前节点的指针，初始指向链表的头部 lst.head
	//循环条件是 e 不为 nil（即未到达链表末尾）
	//在每次循环中，将当前节点 e 的值 e.val 添加到切片 elems 中
	for e := lst.head; e != nil; e = e.next {
		elems = append(elems, e.val)
	}
	//循环结束后，返回包含链表中所有元素的切片 elems
	return elems
}

func main() {
	var s = []string{"foo", "bar", "zoo"}

	fmt.Println("index of zoo:", SlicesIndex(s, "zoo"))

	_ = SlicesIndex[[]string, string](s, "zoo")
	//定义一个 List[int] 类型的变量 lst，这是一个空的整型链表
	lst := List[int]{}
	//调用push向链表添加元素
	lst.Push(10)
	lst.Push(13)
	lst.Push(23)
	//打印链表中的全部元素
	fmt.Println("list:", lst.AllElements())
}

//输出
//index of zoo: 2
//list: [10 13 23]

🔍泛型理解

代码中看到[T any]之类的字眼就表示这是泛型
灵活性：泛型使得函数和数据结构能够处理多种类型，减少了代码重复。
类型安全：在编译时检查类型，确保类型安全。
简化代码：通过泛型，可以编写更简洁和可重用的代码。

链表、切片泛型还需要多加练习掌握。
无他，唯手熟尔。

💪无人扶我青云志，我自踏雪至山巅。