文章目录
下面的方法省略一些校验，如数组越界等，且都采用泛型(要求go版本 >= 1.18)
移除指定位置的元素
go
package main
import (
"fmt"
)
func Delete[T any](source []T, index int) []T {
return append(source[:index], source[index+1:]...)
}
func main() {
fmt.Println(Delete([]int{1, 2, 3, 4, 5}, 3)) //[1,2,3,5]
}查找元素的位置
找到返回位置，找不到返回 -1
也可以用来判断某个元素是否存在，大于 -1 即存在
go
package main
import (
"fmt"
)
func Delete[T any](source []T, assert func(t T) bool) int {
for index, item := range source {
if assert(item) {
return index
}
}
return -1
}
func main() {
fmt.Println(Delete([]int{1, 2, 3, 4, 5}, func(t int) bool {
return t == 3
}))
// 2
}查找最大最小的元素
go
package main
import (
"fmt"
)
func Find[T any](source []T, assert func(t1, t2 T) bool) T {
max := source[0]
for _, item := range source {
if assert(max, item) {
max = item
}
}
return max
}
func main() {
fmt.Println(Find([]int{1, 2, 22, 8, 11, 3, 4, 5}, func(t1, t2 int) bool {
return t2 > t1
})) //22
fmt.Println(Find([]int{1, 2, 22, 8, 11, 3, 4, 5}, func(t1, t2 int) bool {
return t2 < t1
})) //1
}去重
T 使用 comparable 是因为 map 需要一个可比较的类型
go
package main
import "fmt"
func Uniq[T comparable](collection []T) []T {
result := make([]T, 0, len(collection))
seen := make(map[T]struct{}, len(collection))
for _, item := range collection {
if _, ok := seen[item]; ok {
continue
}
seen[item] = struct{}{}
result = append(result, item)
}
return result
}
func main() {
fmt.Println(Uniq([]int{6, 7, 6, 5})) //[6,7,5]
}使用 struct{}{} 是因为它不占内存
go
package main
func main() {
fmt.Println(unsafe.Sizeof(struct{}{})) // 0
fmt.Println(unsafe.Sizeof(true)) // 1
}随机打乱
这里引入了 i int64，这个是让他们的随机种子不一样，不然在 main中的 10次打印结果都一致
go
package main
import (
"fmt"
"math/rand"
"time"
)
func random[T any](input []T, i int64) []T {
rand.Seed(time.Now().Unix() + i)
for i := len(input) - 1; i >= 0; i-- {
index := rand.Intn(i + 1)
input[index], input[i] = input[i], input[index]
}
return input
}
func main() {
for i := 0; i < 10; i++ {
fmt.Println(random([]int{1, 2, 3, 4, 5, 6, 7, 8, 9}, int64(i)))
}
//下面的结果都一样
for i := 0; i < 10; i++ {
fmt.Println(random([]int{1, 2, 3, 4, 5, 6, 7, 8, 9}, 0))
}
}排序
这里展示的是选择排序，可以更换其它排序算法
go
package main
import "fmt"
func sort[T any](source []T, assert func(a, b T) bool) []T {
for i := 0; i < len(source); i++ {
for j := i + 1; j < len(source); j++ {
if assert(source[i], source[j]) {
source[j], source[i] = source[i], source[j]
}
}
}
return source
}
func main() {
r := sort([]int{1, 4, 3, 9, 7, 8, 5}, func(a, b int) bool {
return a < b
})
fmt.Println(r) //[9 8 7 5 4 3 1]
}二维排序
在排序的基础上增加了一个 index(要比较的元素位置)，根据二维index位置的元素大小，来决定一维的排序位置
go
package main
import "fmt"
func TwoDimensionalSort[T any](source [][]T, index int, assert func(a, b T) bool) [][]T {
for i := 0; i < len(source); i++ {
for j := i + 1; j < len(source); j++ {
//二维index位置上元素的比较
if assert(source[i][index], source[j][index]) {
//一维位置交换
source[j], source[i] = source[i], source[j]
}
}
}
return source
}
func main() {
result := TwoDimensionalSort([][]int{{1, 3, 5}, {6, 2, 3}, {5, 9, 1}}, 2, func(a, b int) bool {
return a > b
})
fmt.Println(result) //[[5 9 1] [6 2 3] [1 3 5]]
result = TwoDimensionalSort([][]int{{1, 3, 5}, {6, 2, 3}, {5, 9, 1}}, 1, func(a, b int) bool {
return a > b
})
fmt.Println(result) //[[6 2 3] [1 3 5] [5 9 1]]
}sort.Sort 排序
进阶版本使用泛型加 sor.Sort 处理，算法由 sort.Sort 实现，而我只需要实现它排序对象的接口即可,Len()返回元素数量，Less() 比较方式 i 是否要 排在 j 前面，Swap() 交换方式
go
type Interface interface {
// Len is the number of elements in the collection.
Len() int
// Less reports whether the element with index i
// must sort before the element with index j.
//
// If both Less(i, j) and Less(j, i) are false,
// then the elements at index i and j are considered equal.
// Sort may place equal elements in any order in the final result,
// while Stable preserves the original input order of equal elements.
//
// Less must describe a transitive ordering:
// - if both Less(i, j) and Less(j, k) are true, then Less(i, k) must be true as well.
// - if both Less(i, j) and Less(j, k) are false, then Less(i, k) must be false as well.
//
// Note that floating-point comparison (the < operator on float32 or float64 values)
// is not a transitive ordering when not-a-number (NaN) values are involved.
// See Float64Slice.Less for a correct implementation for floating-point values.
Less(i, j int) bool
// Swap swaps the elements with indexes i and j.
Swap(i, j int)
}
go
package main
import (
"fmt"
"sort"
)
type SortStruct[T comparable] struct {
Data [][]T
Assert func(a, b T) bool
Index int
}
func (s SortStruct[T]) Len() int {
return len(s.Data)
}
func (s SortStruct[T]) Less(i, j int) bool {
return s.Assert(s.Data[i][s.Index], s.Data[j][s.Index])
}
func (s SortStruct[T]) Swap(i, j int) {
s.Data[i], s.Data[j] = s.Data[j], s.Data[i]
}
func main() {
result := SortStruct[int]{
Data: [][]int{
{1, 2, 3},
{3, 1, 2},
{6, 7, 8},
},
Assert: func(a, b int) bool {
return a < b
},
Index: 1,
}
sort.Sort(result)
fmt.Println(result.Data) //[[3 1 2] [1 2 3] [6 7 8]]
}