记录学到的一些简单算法（golang实现，不定期更新）

1.取余

取余常用于判断整数的奇偶性，但其实判断奇偶性可以用&，没必要用取余操作

	var num = 17
	if (num & 1) == 1 {
		fmt.Println("奇数")
	} else {
		fmt.Println("偶数")
	}

一次循环遍历二维数组：遍历二维数组通常要遍历两次，但是用取余操作可以遍历一次

	const (
		row = 5
		col = 7
	)
	// 创建一个二维数组
	var arr [row][col]int
	for i := 0; i < row; i++ {
		for j := 0; j < col; j++ {
			arr[i][j] = i * j
		}
	}
	fmt.Println(arr)
	// 遍历
	var arr2 [row][col]int
	for i := 0; i < row*col; i++ {
		r := i / col
		c := i % col
		arr2[r][c] = c * r
	}
	fmt.Println(arr2)

“环形”数组：循环遍历一个数组

	n := 10
	for i := 0; i < n; i++ {
		mod := i % len(arr)
		fmt.Println(arr[mod])
	}

2.topN问题：选取数组中最大的n个值

function 1 : 利用sort.Sort()方法

type arrSort []int
func (a arrSort) Len() int           { return len(a) }
func (a arrSort) Swap(x, y int)      { a[x], a[y] = a[y], a[x] }
func (a arrSort) Less(x, y int) bool { return a[x] > a[y] }

func topN() {
	arr := []int{1, 7, 4, 3, 5, 9, 2, 8, 6, 0}
	sort.Sort(arrSort(arr))
	fmt.Println(arr)
}

function 2 : 初始化一个长度为k的数组arrN，然后遍历原数组，将大于arrN中最小值的元素放入arrN中，并舍弃掉arrN中最小的元素

func desc(arrN []int, e int) []int {
	var result []int
	for j := 0; j < len(arrN); j++ {
		if arrN[j] < e {
			result = append(result, arrN[0:j]...)
			result = append(result, e)
			if j < len(arrN)-1 {
				result = append(result, arrN[j:len(arrN)-1]...)
			}
			return result
		}
	}
	return arrN
}

func topN() {
	arr := []int{1, 7, 4, 3, 5, 9, 2, 8, 6, 0}
	n := 3
	arrN := arr[0:n]
	sort.Sort(arrSort(arrN))
	for i := n; i < len(arr); i++ {
		if arr[i] > arrN[n-1] {
			arrN = desc(arrN, arr[i])
		}
	}
	fmt.Println("topN", arrN)
}

一般而言，数组较大，用function2; 较小，用function1