Golang实现基本排序算法

手写相关排序算法 （待更新）

package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
	"strings"
)

func simpleSort(data *[]int) {
	// O(n^2) ，每次从子列表找出最小的位置和当前位置交换
	for i := 0; i < len(*data); i++ {
		minIndex := i
		for j := i; j < len(*data); j++ {
			// 从当前元素群中找出比minIndex位置更小的元素
			if (*data)[j] < (*data)[minIndex] {
				minIndex = j
			}
		}
		if minIndex != i {
			(*data)[i], (*data)[minIndex] = (*data)[minIndex], (*data)[i]
		}
	}
}

func insertSort(data *[]int) {
	// 直接插入排序，从后往前，若[0,i-1]有序，将[i]与前面逐个比较，比它大的往后挪
	for i := 1; i < len(*data); i++ { //元素长度要大于1
		temp := (*data)[i]
		j := i
		for {
			if j < 1 || (*data)[j-1] < temp { // 当扫描到一个值比temp小离开停止
				break
			}
			(*data)[j] = (*data)[j-1]
			j = j - 1
		}
		(*data)[j] = temp
	}
}

func partition(data *[]int, left, right int) int {
	// 记第一个为划分节点
	temp := (*data)[left]
	for {
		if left >= right {
			break
		}
		for {
			// 从右往左
			if left >= right || (*data)[right] <= temp {
				break //当前ritgh处值比temp小
			}
			right = right - 1
		}
		// 右往左找到第一个小于等于temp的元素，进行交换
		(*data)[left] = (*data)[right]
		for {
			//从左往右
			if left >= right || (*data)[left] > temp {
				break // 当前left处值比temp大
			}
			left = left + 1
		}
		// 左往右找到第一个大于temp的元素，进行交换
		(*data)[right] = (*data)[left]
	}
	// 直到left和right相遇
	(*data)[left] = temp
	return left
}

func quickSort(data *[]int, left, right int) {
	// 快速排序，每次将mid划分左右两个区间，区间里面再进行划分
	// 有序时间复杂度为O(n^2) 无序为O(n log n)
	if left < right {
		mid := partition(data, left, right)
		quickSort(data, left, mid-1)
		quickSort(data, mid+1, right)
	}
}

func main() {
	input := bufio.NewScanner(os.Stdin)
	for input.Scan() {
		n, _ := strconv.Atoi(input.Text())
		input.Scan()
		str := strings.Split(input.Text(), " ")
		data := make([]int, 0)
		for i := 0; i < n; i++ {
			temp, _ := strconv.Atoi(str[i])
			data = append(data, temp)
		}
		// 简单选择排序
		// simpleSort(&data)
		// 插入排序
		// insertSort(&data)
		// 快速排序
		quickSort(&data, 0, len(data)-1)
		fmt.Println(data)
	}
}

2. golang对结构体排序
   

package main

import (
	"bufio"
	"fmt"
	"os"
	"sort"
	"strconv"
	"strings"
)

type student struct {
	id      string
	all_pf  int // 总体排名
	addr    int // 考场号
	addr_pf int // 考场内排名
	score   int
}

func main() {
	input := bufio.NewScanner(os.Stdin)
	input.Scan()
	n, _ := strconv.Atoi(input.Text())
	nums := 0

	resu := make([]student, 0)
	for input.Scan() {
		stus := make([]student, 0)
		m, _ := strconv.Atoi(input.Text())
		for i := 0; i < m; i++ {
			// 读取m行考生数据
			input.Scan()
			stu := student{}
			str := strings.Split(input.Text(), " ")
			stu.id = str[0]
			stu.addr = nums
			stu.score, _ = strconv.Atoi(str[1])
			stus = append(stus, stu)
		}
		fmt.Println(stus)
		// 对当前内部排序
		sort.SliceStable(stus, func(i, j int) bool {
			if stus[i].score > stus[j].score {
				return true
			} else if stus[i].score == stus[j].score {
				if stus[i].id < stus[j].id {
					return true
				} else {
					return false
				}
			} else {
				return false
			}
		})
		// 排完序对内部的编号赋值
		for i := 0; i < len(stus); i++ {
			if i == 0 {
				stus[i].addr_pf = 1
			} else {
				if stus[i].score == stus[i-1].score {
					stus[i].addr_pf = stus[i-1].addr_pf
				} else {
					stus[i].addr_pf = i + 1
				}
			}
		}
		resu = append(resu, stus...)
		nums = nums + 1
		if nums == n {
			break
		}
	}
	fmt.Println(resu)
	sort.SliceStable(resu, func(i, j int) bool {
		if resu[i].score > resu[j].score {
			return true
		} else if resu[i].score == resu[j].score {
			if resu[i].id < resu[j].id {
				return true
			} else {
				return false
			}
		} else {
			return false
		}

	})
	// 排完序对内部的编号赋值
	for i := 0; i < len(resu); i++ {
		if i == 0 {
			resu[i].all_pf = 1
		} else {
			if resu[i].score == resu[i-1].score {
				resu[i].all_pf = resu[i-1].all_pf
			} else {
				resu[i].all_pf = i + 1
			}
		}
	}
	fmt.Println(resu)
}