企业网站留言板,深圳百度竞价推广,网站代理最快最干净,网页设计图片排版模板文章目录 移除指定位置的元素查找元素的位置查找最大最小的元素去重随机打乱排序二维排序sort.Sort 排序 下面的方法省略一些校验#xff0c;如数组越界等#xff0c;且都采用泛型(要求go版本 1.18) 移除指定位置的元素
package mainimport (fmt
)func Del… 文章目录 移除指定位置的元素查找元素的位置查找最大最小的元素去重随机打乱排序二维排序sort.Sort 排序 下面的方法省略一些校验如数组越界等且都采用泛型(要求go版本 1.18) 移除指定位置的元素
package mainimport (fmt
)func Delete[T any](source []T, index int) []T {return append(source[:index], source[index1:]...)
}func main() {fmt.Println(Delete([]int{1, 2, 3, 4, 5}, 3)) //[1,2,3,5]
}
查找元素的位置
找到返回位置找不到返回 -1 也可以用来判断某个元素是否存在大于 -1 即存在
package mainimport (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
}
查找最大最小的元素
package mainimport (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})) //22fmt.Println(Find([]int{1, 2, 22, 8, 11, 3, 4, 5}, func(t1, t2 int) bool {return t2 t1})) //1
}去重
T 使用 comparable 是因为 map 需要一个可比较的类型
package mainimport fmtfunc 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{}{} 是因为它不占内存
package mainfunc main() {fmt.Println(unsafe.Sizeof(struct{}{})) // 0fmt.Println(unsafe.Sizeof(true)) // 1
}
随机打乱
这里引入了 i int64这个是让他们的随机种子不一样不然在 main中的 10次打印结果都一致
package mainimport (fmtmath/randtime
)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))}
}
排序
这里展示的是选择排序可以更换其它排序算法
package mainimport fmtfunc 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位置的元素大小来决定一维的排序位置
package mainimport fmtfunc 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() 交换方式
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)
}package mainimport (fmtsort
)type SortStruct[T comparable] struct {Data [][]TAssert func(a, b T) boolIndex 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]]
}
