golang泛型体验

支持int、float、string类型打印的print函数

package main

import "fmt"

func print[T any] (arr []T) {
    for _, v := range arr {
        fmt.Print(v)
        fmt.Print(" ")
    }
    fmt.Println("")
}

func main() {
    strs := []string{"Hello", "World", "Generics"}
    decs := []float64{3.14, 1.14, 1.618, 2.718}
    nums := []int{2, 4, 6, 8}

    print(strs)
    print(decs)
    print(nums)
}

go1.18上运行

 查找算法

func find[T comparable] (arr []T, elem T) int {
    for i, v := range arr {
        if v == elem {
            return i
        }
    }
    return -1
}

数据结构

Stack栈

package main

import "fmt"

type stack[T any] []T

func (s *stack[T]) push(elem T) {
    *s = append(*s, elem)
}

func (s *stack[T]) pop() {
    if len(*s) > 0 {
        *s = (*s)[:len(*s)-1]
    }
}

func (s *stack[T]) top() *T {
    if len(*s) > 0 {
        return &(*s)[len(*s)-1]
    }
    return nil
}

func (s *stack[T]) len() int {
    return len(*s)
}

func (s *stack[T]) print() {
    for _, elem := range *s {
        fmt.Print(elem)
        fmt.Print(" ")
    }
    fmt.Println("")
}

func main() {
    ss := stack[string]{}
    ss.push("Hello")
    ss.push("World")
    ss.push("Zhi")
    ss.push("Chen")
    ss.print()
    fmt.Printf("stack top is - %v\n", *(ss.top()))
    ss.pop()
    ss.pop()
    ss.print()

    ns := stack[int] {}
    ns.push(10)
    ns.push(20)
    ns.print()
    ns.pop()
    ns.print()
    *ns.top() += 1
    ns.print()
    ns.pop()
    fmt.Printf("stack top is - %v\n", ns.top())
}

 LinkList双向链表

add()

push()

del()compareable

print()

package main

import "fmt"

type node[T comparable] struct {
    data T
    prev *node[T]
    next *node[T]
}

type list[T comparable] struct {
    head, tail *node[T]
    len int
}

func (l *list[T]) isEmpty() bool {
    return l.head == nil && l.tail == nil
}

func (l *list[T]) add(data T) {
    n := &node[T] {
        data: data,
        prev: nil,
        next: l.head,
    }
    if l.isEmpty() {
        l.head = n 
        l.tail = n
    }
    l.head.prev = n 
    l.head = n
}

func (l *list[T]) push(data T) {
    n := &node[T]{
        data: data,
        prev: l.tail,
        next: nil,
    }
    if l.isEmpty() {
        l.head = n 
        l.tail = n 
    }
    l.tail.next = n 
    l.tail = n 
}

func (l *list[T]) del(data T) {
    for p := l.head; p != nil; p = p.next {
        if data == p.data {
            if p == l.head {
                l.head = p.next
            }
            if p == l.tail {
                l.tail = p.prev
            }
            if p.prev != nil {
                p.prev.next = p.next
            }
            if p.next != nil {
                p.next.prev = p.prev
            }
            return
        }
    }
}

func (l *list[T]) print() {
    if l.isEmpty() {
        fmt.Println("the link list is empty")
        return
    }
    for p:=l.head; p != nil; p=p.next {
        fmt.Printf("[%v] -> ", p.data)
    }
    fmt.Println("nil")
}

func main() {
    var l = list[int]{}
    l.add(1)
    l.add(2)
    l.push(3)
    l.push(4)
    l.add(5)
    l.print()
    
    l.del(5)
    l.del(1)
    l.del(4)
    l.print()
}

 函数式泛型

泛型Map

package main

import (
    "fmt"
    "strings"
)

func print[T any] (arr []T) {
    for _, v := range arr {
        fmt.Print(v)
        fmt.Print(" ")
    }
    fmt.Println("")
}

func gMap[T1 any, T2 any] (arr []T1, f func(T1) T2) []T2 {
    result := make([]T2, len(arr))
    for i, elem := range arr {
        result[i] = f(elem)
    }
    return result
}

func main() {
    nums := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
    squares := gMap(nums, func(elem int) int {
        return elem * elem
    })
    print(squares)

    strs := []string{"Zhi", "Chen", "MegaEase"}
    upstrs := gMap(strs, func(s string) string {
        return strings.ToUpper(s)
    })
    print(upstrs)

    dict := []string{"零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖"}
    strs = gMap(nums, func(elem int) string {
        return dict[elem]
    })
    print(strs)
}

 

 泛型Reduce

package main

import (
    "fmt"
)

func gReduce[T1 any, T2 any] (arr []T1, init T2, f func(T2, T1) T2) T2 {
    result := init
    for _, elem := range arr {
        result = f(result, elem)
    }
    return result
}

func main() {
    nums := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
    sum := gReduce(nums, 0, func(result, elem int) int {
        return result + elem
    })
    fmt.Printf("Sum = %d\n", sum)
}

 泛型filter

用来做过滤的，把数据中一些符合条件（filter in）或是不符合条件（filter out）的数据过滤出来

bool

package main

import (
    "fmt"
)

func print[T any] (arr []T) {
    for _, v := range arr {
        fmt.Print(v)
        fmt.Print(" ")
    }
    fmt.Println("")
}

func gFilter[T any] (arr []T, in bool, f func(T) bool) []T {
    result := []T{}
    for _, elem := range arr {
        choose := f(elem)
        if (in && choose) || (!in && !choose) {
            result = append(result, elem)
        }
    }
    return result
}

func gFilterIn[T any] (arr []T, f func(T) bool) []T {
    return gFilter(arr, true, f)
}

func gFilterOut[T any] (arr []T, f func(T) bool) []T {
    return gFilter(arr, false, f)
}

func main() {
    nums := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
    odds := gFilterIn(nums, func(elem int) bool {   // 把数组中所有的奇数过滤出来
        return elem % 2 == 1
    })
    print(odds)
}