【GO-排序和查找】

一、排序的定义

排序是将一组诗句，依指定的顺序进行排列的过程。
排序的分类：
1、内部排序：将需要处理的所有数据都加载到内部存储器中进行排序（交换式排序法、选择式排序法和插入式排序法）；
2、外部排序法：数据量过大，无法全部加载到内存中，需要借助外部存储进行排序（合并排序法、直接合并排序法）。

交换排序法：运用数据值比较后，依判断规则对数据位置进行交换，以达到排序的目的：
1、冒泡排序法；
2、快速排序法。

二、冒泡排序

冒泡排序规则：
1、一共会经过arr.length-1次的轮次比较，每一轮将会确定一个数的位置；
2、每一轮的比较次数在逐渐的减少1；
3、当发现前面的一个数比后面的一个数大的时候，就进行了交换吧；
将五个五序数列按照从小到大排列：

package main

import (
	"fmt"
)

func BubbleSort(arr *[5]int) { //指向数组的指针，函数中修改才会影响数组
	fmt.Println("排序前arr=", (*arr))
	temp := 0
	for i := 0; i < len(*arr)-1; i++ { //双层循环
		for j := 0; j < len(*arr)-1-i; j++ {
			if (*arr)[j] > (*arr)[j+1] {
				temp = (*arr)[j]
				(*arr)[j] = (*arr)[j+1]
				(*arr)[j+1] = temp
			}
		}
	}
	fmt.Println("排序后arr=", (*arr))
}

func main() {
	//1、创建一个数组
	var arr [5]int = [...]int{2, 1, 55, 47, 11}
	//将数组传递给一个函数
	BubbleSort(&arr)
}

输出

PS D:\goproject\src\go_code\chaptor8\demo1> go run .\main.go
排序前arr= [2 1 55 47 11]
排序后arr= [1 2 11 47 55]

三、顺序查找

package main

import (
	"fmt"
)

func main() {
	var names [4]string = [...]string{"白眉鹰王", "金毛狮王", "紫衫龙王", "青翼蝠王"}
	var heroName = ""
	fmt.Println("请输出要查找的人名")
	fmt.Scanln(&heroName)
	//顺序查找第一种方式
	for i := 0; i < len(names); i++ {
		if heroName == names[i] {
			fmt.Printf("找到%v,下标为%v\n", names[i], i)
			break
		} else if i == (len(names) - 1) {
			fmt.Printf("没有找到%v", heroName)
		}
	}
	//顺序查找第二种
	index := -1
	for i := 0; i < len(names); i++ {
		if heroName == names[i] {
			index = i //将找到的值对应的下标赋值给index
			break
		}
	}
	if index != -1 {
		fmt.Printf("找到%v,下标为%v\n", heroName, index)
	} else {
		fmt.Printf("没有找到%v", heroName)
	}

}

输出

PS D:\goproject\src\go_code\chaptor8\demo2> go run .\main.go
请输出要查找的人名
金毛狮王
找到金毛狮王,下标为1

四、二分查找

二分查找需要是一个有序数组

package main

import (
	"fmt"
)

//二分查找
func BinaryFind(arr *[6]int, leftIndex int, rightIndex int, findVal int) {
	//判断leftIndex是否大于rightIndex
	if leftIndex > rightIndex {
		fmt.Println("找不到")
		return
	}

	middle := (leftIndex + rightIndex) / 2
	if (*arr)[middle] > findVal {
		//说明要找的数在leftIndex ---- middle-1之间
		BinaryFind(arr, leftIndex, middle-1, findVal)
	} else if (*arr)[middle] < findVal {
		//说明要找的数在middle+1----rightIndex之间
		BinaryFind(arr, middle+1, rightIndex, findVal)
	} else {
		//找到了
		fmt.Printf("找到了，下标为%v\n", middle)
	}
}

func main() {
	arr := [6]int{1, 8, 10, 89, 1000, 1234}
	BinaryFind(&arr, 0, len(arr)-1, 1234)
}

输出

PS D:\goproject\src\go_code\chaptor8\demo3> go run .\main.go
找到了，下标为5

五、二维数组

定义：一维数组里面的元素也是数组。
使用方式：先声明/定义再赋值
（1）语法：var 数组名 [大小][大小]类型
（2）比如 var arr [2][3]int[][] ，在赋值

输出一个二维数组

package main

import (
	"fmt"
)

func main() {
	/*
		0 0 0 0 0 0
		0 1 0 0 0 0
		0 0 2 0 0 0
		0 0 0 3 0 0
		0 0 0 0 4 0
	*/
	//声明二维数组
	var arr [5][6]int
	//赋初始值
	arr[1][1] = 1
	arr[2][2] = 2
	arr[3][3] = 3
	arr[4][4] = 4

	for i := 0; i < 5; i++ {
		for j := 0; j < 6; j++ {
			fmt.Print(arr[i][j], " ")
		}
		fmt.Println()
	}
	//fmt.Println(arr) //如果不赋值，均为0
}

输出

PS D:\goproject\src\go_code\chaptor8\demo4> go run .\main.go
0 0 0 0 0 0 
0 1 0 0 0 0
0 0 2 0 0 0
0 0 0 3 0 0
0 0 0 0 4 0

其他声明方式

package main

import (
	"fmt"
)

func main() {
	var arr1 [2][3]int = [2][3]int{{1, 2, 3}, {4, 5, 6}}
	fmt.Println("arr1=", arr1)

	var arr2 [2][3]int = [...][3]int{{1, 2, 3}, {4, 5, 6}}
	fmt.Println("arr2=", arr2)

	var arr3 = [2][3]int{{1, 2, 3}, {4, 5, 6}}
	fmt.Println("arr3=", arr3)

	var arr4 = [...][3]int{{1, 2, 3}, {4, 5, 6}}
	fmt.Println("arr4=", arr4)
}

输出

PS D:\goproject\src\go_code\chaptor8\demo4> go run .\main.go
arr1= [[1 2 3] [4 5 6]]
arr2= [[1 2 3] [4 5 6]]
arr3= [[1 2 3] [4 5 6]]
arr4= [[1 2 3] [4 5 6]]

二维数组的遍历

package main

import (
	"fmt"
)

func main() {
	var arr = [...][3]int{{1, 2, 3}, {4, 5, 6}}
	//for 循环
	for i := 0; i < len(arr); i++ {
		for j := 0; j < len(arr[i]); j++ {
			fmt.Printf("%v\t", arr[i][j])
		}
		fmt.Println()
	}

	//for range循环
	for i, v := range arr {
		for j, v2 := range v {
			fmt.Printf("arr[%v][%v]=%v\t", i, j, v2)
		}
		fmt.Println()
	}
}

输出

PS D:\goproject\src\go_code\chaptor8\demo5> go run .\main.go
1       2       3
4       5       6
arr[0][0]=1     arr[0][1]=2     arr[0][2]=3
arr[1][0]=4     arr[1][1]=5     arr[1][2]=6