简单排序算法

选择排序

        从i=0开始，默认将arr[i]当作数组中最小值，将其索引赋值给minIndex，然后依次匹配 len(arr) > j > i 的数，如果arr[j]<arr[minIndex]的话，就说明后续数组中有值比arr[i]小，然后将此值的索引赋值给minIndex，直到遍历完len(arr) > j > i，minIndex中存储的就是len(arr) > j > i中最小的值的索引，然后通过swap函数将其与索引为i的值互换，也就是将最小值调换到了最前面，也就是 <=i的数组序列已经是有序的了，然后再对>i的数组序列依次执行以上操作。

其实说白了，就是依次将数组中的当轮最小值调到了当轮数组序列的最前面。

package main

import (
	"fmt"
	"math/rand"
	"time"
)

func selectionSort(arr []int) []int {
	if arr == nil || len(arr) < 2 {
		return nil
	}
	for i := 0; i < len(arr); i++ {
		minIndex := i
		for j := i + 1; j < len(arr); j++ {
			if arr[j] < arr[minIndex] {
				minIndex = j
			}
		}
		swap(&arr, i, minIndex)
	}
	return arr
}

func swap(arr *[]int, i int, j int) {
	//(*arr)[i] = (*arr)[i] ^ (*arr)[j]
	//(*arr)[j] = (*arr)[i] ^ (*arr)[j]
	//(*arr)[i] = (*arr)[i] ^ (*arr)[j]
	temp := (*arr)[i]
	(*arr)[i] = (*arr)[j]
	(*arr)[j] = temp
}

func main() {
	arr := getRandomArr()
	//arr := []int{39, 67, 16, 57, 98, 10, 54, 89, 3, 21}
	printArr(arr)
	selectionSort(arr)
	printArr(arr)
}

func getRandomArr() []int {
	var arr []int
	maxIndex := 10
	minIndex := 0
	rand.Seed(time.Now().UnixNano())
	for i := minIndex; i < maxIndex; i++ {
		arr = append(arr, rand.Intn(100))
	}
	return arr
}

func printArr(arr []int) {
	for i := 0; i < len(arr); i++ {
		fmt.Print(arr[i])
		fmt.Print(" ")

	}
	fmt.Println()
}

插入排序

简单来说，插入排序就是i遍历1到n-1，每一次将i之前的数组序列给排序好。因为在i之前的数组序列已经是有序的了，所以只要确定arr[i]在i之前的数组序列中的位置即可，找到他的位置之后将其插入进去。

package class1

import (
	"algorithms/moddle"
)

func SelectionSort(arr []int) []int {
	if arr == nil || len(arr) < 2 {
		return nil
	}
	for i := 0; i < len(arr); i++ {
		minIndex := i
		for j := i + 1; j < len(arr); j++ {
			if arr[j] < arr[minIndex] {
				minIndex = j
			}
		}
		moddle.Swap(&arr, i, minIndex)
	}
	return arr
}

冒泡排序

简单来说，就是将每次遍历的最大值放到最后，两两比较，将较大的值换到后面的位置，直到将最大值放到最后。

package class1

import (
	"algorithms/moddle"
)

func BubbleSort(arr []int) []int {
	if arr == nil || len(arr) < 2 {
		return nil
	}
	for e := len(arr) - 1; e > 0; e-- {
		for i := 0; i < e; i++ {
			if arr[i] > arr[i+1] {
				moddle.Swap(&arr, i, i+1)
			}
		}
	}
	return arr
}

以上排序算法的时间复杂度都为O(N^2)