本文发布于Cylon的收藏册,转载请著名原文链接~

冒泡排序

https://www.cnblogs.com/onepixel/articles/7674659.html

img

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
package main

import (
  "fmt"
)

func bubbleSort(slice []int) []int {
	for n := 0; n <= len(slice); n++ {
		for i := 1; i < len(slice)-n; i++ {
			if slice[i] < slice[i-1] {
				slice[i], slice[i-1] = slice[i-1], slice[i]
			}
		}
	}
	return slice
}


func main() {

	var arr = [...]int{99, 51, 41, 2, 31}

	var rarr = bubble(arr[:])
	fmt.Println(rarr)
}

比较排序

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
package main

import (
	"fmt"
)

func selectionSort(slice []int) []int {
	for n := 0; n <= len(slice); n++ {
		fmt.Println(slice)
		fmt.Println("#####################")
		for i := n + 1; i < len(slice); i++ {

			if slice[n] > slice[i] {
				slice[n], slice[i] = slice[i], slice[n]
				fmt.Println(slice)
			}
		}
		fmt.Println("---------------")
	}
	return slice
}

func main() {

	var arr = [...]int{99, 51, 41, 2, 31}

	var rarr = selectionSort(arr[:])
	fmt.Println(rarr)
}

img

插入排序

思路:将数组拆分为一个有序的,一个无序的。初始时下标0永远为有序数组。

建立循环,从下标1开始到数组的长度,每个都与前一个进行对比,如果比前一个值小,就互相换位,当当前值比上一个值大时,说明当前值之前都是已经排序好的数组。就退出。

例子:如该数组 [...]int{10, 56, 4, 654, 8, 997}

第一次循环时,n=1 i=1 56 > 10 跳出。

第二次循环时,{10, 56, 4, 654, 8, 997} n=2 i=n=24<56 互换,值为 {10, 4, 56, 654, 8, 997} ,内部循环继续进行,i=1 4<10互换为 [4 10 56 654 8 997] 。内部循环结束,条件为i<0

img

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
package main

import (
	"fmt"
)

func insertSort(arr []int) {
	for n := 1; n < len(arr); n++ {
		for i := n; i > 0; i-- {
			if arr[i] > arr[i-1] {
				break
			}
			arr[i], arr[i-1] = arr[i-1], arr[i]
			fmt.Println(arr)
		}
	}
}

func main() {
	var array = [...]int{10, 56, 4, 654, 8, 997}
	insertSort(array[:])

	fmt.Println(array)
}

快速排序

思路:以一个基准数将数组拆分为两个,一边大于这个数,一边小于这个数。从数组第0个开始,首先先记录此基准数的下标和值 {312, 84, 543, 5, 100, 23} ,k=0 v=312。需要传入一个从哪里开始到哪里的位置。这里基准数为第一个,顾循环位置就从0+1开始 循环完之后为 84 84 543 5 100 23

img

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
package main

import (
	"fmt"
)

func qsort(arr []int, start int, end int) {
	if start >= end {
		return
	}

	key := start
	value := arr[start] //记录当前基准值位置
	fmt.Println(arr)
	for n := start + 1; n <= end; n++ {
		// a[n] < arr[start]
		if arr[n] < value {
			arr[key] = arr[n]   //就将a[n]挪至arr[key]所在位置
			arr[n] = arr[key+1] //a[n]空缺了,将arr[key]向后移动一位
			// 理论上现在值为这个 {84, 84, 543, 5, 100, 23}
			key++ //key的位置改变了1位,key++
			//最后在将进位后的arr[key] = 之前保存的value即为
			// value=321 {84, 312, 543, 5, 100, 23}
			//这样完成了替换
		}
	}

	arr[key] = value
	fmt.Println("---------------------------")
	//一轮循环后该数组为[84 5 100 23 312 543]
	//将基准数两边的数进行进行排序 此时 key=3 start=0 左边为 start-key-1
	qsort(arr, start, key-1)
	qsort(arr, key+1, end) //右边为key+1-end
}

func main() {
	var array = [...]int{312, 84, 543, 5, 100, 23}
	qsort(array[:], 0, len(array)-1)
	fmt.Println(array)
}

img

本文发布于Cylon的收藏册,转载请著名原文链接~

链接:https://www.oomkill.com/2018/10/go-datasort/

版权:本作品采用「署名-非商业性使用-相同方式共享 4.0 国际」 许可协议进行许可。