Skip to content

Instantly share code, notes, and snippets.

View xmapst's full-sized avatar

小学课本的小明 xmapst

23 followers · 0 following
View GitHub Profile
@xmapst
xmapst / sortquery.go
Last active February 22, 2023 00:49
SortQuery
package query
func SortQuery(objPtr interface{}) (res []string, err error) {
reflectObjType := reflect.TypeOf(objPtr)
if reflectObjType.Kind() != reflect.Ptr {
return nil, errors.New("objPtr can only be pointers")
}
if reflectObjType.Elem().Kind() != reflect.Struct {
return nil, errors.New("objPtr can only be struct")
}
@xmapst
xmapst / radixsort.go
Last active February 22, 2023 00:50
RadixSort
package query
func Sort(nums []int) []int {
numberBit := howManyBit(maximum(nums))
// 循环的次数
// 定义一个rec 二维切片 rec[i][x] 用来接受尾数是 i的数字
for i := 0; i < numberBit; i++ {
rec := make([][]int, 10)
@xmapst
xmapst / compareinteger.go
Last active February 22, 2023 00:50
CompareInteger
package compare
type signed interface {
~int | ~int8 | ~int16 | ~int32 | ~int64
}
type unsigned interface {
~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr
}
@xmapst
xmapst / bubblesort.go
Last active February 22, 2023 00:51
冒泡排序的原理：对于一个数组里所有的元素进行两两比较，发生大于则变换数组下标则为升序排序，发生小于则变换数据下标的则为降序排序
package query
func Sort[T constraints.Ordered](buf []T) {
for i := 0; i < len(buf)-1; i++ {
flag := false
for j := 1; j < len(buf)-i; j++ {
if buf[j-1] > buf[j] {
tmp := buf[j-1]
buf[j-1] = buf[j]
buf[j] = tmp
@xmapst
xmapst / choicesort.go
Last active February 22, 2023 00:51
选择排序（Selection sort）是一种简单直观的排序算法。它的工作原理是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。 选择排序是不稳定的排序方法。
package query
func Sort[T constraints.Ordered](buf []T) {
for i := 0; i < len(buf)-1; i++ {
min := i
for j := i; j < len(buf); j++ {
if buf[min] > buf[j] {
min = j
}
}
@xmapst
xmapst / insertsort.go
Last active February 22, 2023 00:52
一个已经有序的数据序列，要求在这个已经排好的数据序列中插入一个数，但要求插入后此数据序列仍然有序，这个时候就要用到一种新的排序方法——插入排序法
func Sort[T constraints.Ordered](buf []T) {
for i := 1; i < len(buf); i++ {
for j := i; j > 0; j-- {
if buf[j] < buf[j-1] {
tmp := buf[j-1]
buf[j-1] = buf[j]
buf[j] = tmp
} else {
break
@xmapst
xmapst / MergeSort.go
Last active February 22, 2023 00:52
归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。
func Sort[T constraints.Ordered](buf []T) {
tmp := make([]T, len(buf))
merge_sort[T](buf, 0, len(buf)-1, tmp)
}
func merge_sort[T constraints.Ordered](a []T, first, last int, tmp []T) {
if first < last {
middle := (first + last) / 2
@xmapst
xmapst / Quicksort.go
Last active February 22, 2023 00:52
快速排序（Quicksort）是对冒泡排序的一种改进。 快速排序由C. A. R. Hoare在1962年提出。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
package quicksort
func Sort[T constraints.Ordered](buf []T) {
quick(buf, 0, len(buf)-1)
}
func quick[T constraints.Ordered](a []T, l, r int) {
if l >= r {
return
}
@xmapst
xmapst / ShellSort.go
Last active February 22, 2023 00:52
希尔排序(Shell’s Sort)是插入排序的一种又称“缩小增量排序”（Diminishing Increment Sort），是直接插入排序算法的一种更高效的改进版本。希尔排序是非稳定排序算法。该方法因D.L.Shell于1959年提出而得名。
package shellsort
func Sort[T constraints.Ordered](buf []T) {
length := len(buf)
incre := length
for {
incre /= 2
for k := 0; k < incre; k++ {
for i := k + incre; i < length; i += incre {
for j := i; j > k; j -= incre {
@xmapst
xmapst / Heapsort.go
Last active February 22, 2023 00:52
堆排序（英语：Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。
pachage heapsort
func Sort[T constraints.Ordered](buf []T) {
n := len(buf)
for i := (n - 1) / 2; i >= 0; i-- {
minHeapFixdown[T](buf, i, n)
}
for i := n - 1; i > 0; i-- {
temp := buf[0]