go语言基础知识学习第三天

算法实现过程

Bubble 冒泡排序

// 第一个`[]int`是表示arrayzor是一个列表; 第二个`[]int`是表示返回结果是一个列表
func bubbleSort(arrayzor []int) []int {
	// 设置一个状态条件 swapped
	swapped := true
	for swapped {
		// 如果没有经过内层for循环会跳出外层循环
		swapped = false
		// 内层for循环 当前面数据较大时会交换两个数据直到获取最大值
		for i := 0; i < len(arrayzor)-1; i++ {
			if arrayzor[i+1] < arrayzor[i] {
				swap(arrayzor, i, i+1)
				swapped = true
			}
		}
	}
	// 返回经过排序后的列表
	return arrayzor
}

// 通过中间值来交换两个数据
func swap(arrayzor []int, i, j int) {
	tmp := arrayzor[j]
	arrayzor[j] = arrayzor[i]
	arrayzor[i] = tmp
}

Selection 选择排序

func selectionSort(arr []int) []int {
	// 两层for循环
	for i := 0; i < len(arr); i++ {
		//首先设置第 i 个元素为最小值
		min := i
		//从后面开始比较找到最小值
		for j := i + 1; j < len(arr); j++ {
			if arr[j] < arr[min] {
				min = j
			}
		}
		//新建一个变量tmp来交换元素
		tmp := arr[i]
		arr[i] = arr[min]
		arr[min] = tmp
	}
	return arr
}

Insertion 插入排序

// 元素是插入到一段已经排好序的列表中
func insertionSort(arr []int) []int {
	// 外层循环out从1开始
	for out := 1; out < len(arr); out++ {
		// 开始时候 temp = arr[1] in=1
		temp := arr[out]
		in := out
		// 从后往前开始比较 判断条件为in大于零和arr[0]>arr[1]
		for ; in > 0 && arr[in-1] >= temp; in-- {
			arr[in] = arr[in-1]
		}
		arr[in] = temp
	}
	return arr
}

快速排序

import (
	"math/rand"
)

func quickSort(arr []int) []int {

	if len(arr) <= 1 {
		return arr
	}
	//随机获取一个随机数
	median := arr[rand.Intn(len(arr))]

	lowPart := make([]int, 0, len(arr))
	highPart := make([]int, 0, len(arr))
	middlePart := make([]int, 0, len(arr))
	
	//获取大于median的列表、等于median的列表、大于median的列表
	for _, item := range arr {
		switch {
		case item < median:
			lowPart = append(lowPart, item)
		case item == median:
			middlePart = append(middlePart, item)
		case item > median:
			highPart = append(highPart, item)
		}
	}
	//采用函数递归的思想
	lowPart = quickSort(lowPart)
	highPart = quickSort(highPart)

	lowPart = append(lowPart, middlePart...)
	lowPart = append(lowPart, highPart...)

	return lowPart
}

Merge 归并排序

func merge(a []int, b []int) []int {
	// 新建一个长度控制的空列表
	var r = make([]int, len(a)+len(b))
	var i = 0
	var j = 0


	for i < len(a) && j < len(b) {

		if a[i] <= b[j] {
			r[i+j] = a[i]
			i++
		} else {
			r[i+j] = b[j]
			j++
		}

	}
	
	for i < len(a) {
		r[i+j] = a[i]
		i++
	}

	for j < len(b) {
		r[i+j] = b[j]
		j++
	}

	return r

}

func Mergesort(items []int) []int {

	if len(items) < 2 {
		return items

	}

	// 将列表从中间分成两部分
	var middle = len(items) / 2
	// 使用递归的思想来解决各自内部的排序
	var a = Mergesort(items[:middle])
	var b = Mergesort(items[middle:])
	// 调用merge函数
	return merge(a, b)

}

Heap 堆排序

//利用堆这种数据结构 子结点的键值或索引总是小于（或者大于）它的父节点
package sorts

//结构体 可以为不同项定义不同的数据类型
type MaxHeap struct {
	slice    []int
	heapSize int
}

func BuildMaxHeap(slice []int) MaxHeap {
	h := MaxHeap{slice: slice, heapSize: len(slice)}
	for i := len(slice) / 2; i >= 0; i-- {
		h.MaxHeapify(i)
	}
	return h
}

func (h MaxHeap) MaxHeapify(i int) {
	l, r := 2*i+1, 2*i+2
	max := i

	if l < h.size() && h.slice[l] > h.slice[max] {
		max = l
	}
	if r < h.size() && h.slice[r] > h.slice[max] {
		max = r
	}
	if max != i {
		h.slice[i], h.slice[max] = h.slice[max], h.slice[i]
		h.MaxHeapify(max)
	}
}

func (h MaxHeap) size() int { return h.heapSize } // ???

func heapSort(slice []int) []int {
	h := BuildMaxHeap(slice)

	for i := len(h.slice) - 1; i >= 1; i-- {
		h.slice[0], h.slice[i] = h.slice[i], h.slice[0]
		h.heapSize--
		h.MaxHeapify(0)
	}
	return h.slice
}

Shell 希尔排序

func shellSort(arr []int) []int {
	// d 为中间值 当d > 0时会d /= 2
	for d := int(len(arr) / 2); d > 0; d /= 2 {
		// 从 d 开始进行循环 len(arr) - d 次
		for i := d; i < len(arr); i++ {
			// j := i
			for j := i; j >= d && arr[j-d] > arr[j]; j -= d {
				// 元素开始交换
				arr[j], arr[j-d] = arr[j-d], arr[j]
			}
		}
	}
	return arr
}