【Golang第6章：排序和查找】golang怎么排序，golang的顺序查找和二分查找，go语言中顺序查找二分查找介绍和案例

介绍

这个是在B站上看边看视频边做的笔记，这一章是GO语言的排序和查找

有golang怎么排序，golang的顺序查找和二分查找，go语言中顺序查找二分查找介绍和案例，具体请看【文章目录】

配套视频自己去B站里面搜【go语言】，最高的播放量就是

里面的注释我写的可能不太对，欢迎大佬们指出╰(°▽°)╯

文章目录

介绍
(六)、排序和查找
章节目录

(六)、排序和查找

一、排序

排序是将一组数据，依指定的顺序进行排列的过程。

排序的分类:

1）内部排序:

指将需要处理的所有数据都加载到内部存储器中进行排序。

包括(交换式排序法、选择式排序法和插入式排序法);

2）外部排序法:

数据量过大，无法全部加载到内存中，需要借助外部存储进行

排序。包括(合并排序法和直接合并排序法)

在这里插入图片描述

冒泡排序法案例:

下面我们举-一个具体的案例来说明冒泡法。我们将五个无序：24, 69, 80, 57, 13使用冒泡排序法将其排成一一个从小到大的有序数列。

在这里插入图片描述

代码思路：

//冒泡排序

func BubbleSort(arr *[5]int) {
	fmt.Println("排序前arr=", (*arr))

	temp := 0 //临时变量，用来做交换
	//完成第一轮排序
	for j := 0; j < 4; j++ {
		if (*arr)[j] > (*arr)[j+1] {
			//交换
			temp = (*arr)[j]
			(*arr)[j] = (*arr)[j+1]
			(*arr)[j+1] = temp
		}
	}
	fmt.Println("第1次排序后arr=", (*arr))

    //完成第二轮排序
	for j := 0; j < 3; j++ {
		if (*arr)[j] > (*arr)[j+1] {
			//交换
			temp = (*arr)[j]
			(*arr)[j] = (*arr)[j+1]
			(*arr)[j+1] = temp
		}
	}
	fmt.Println("第1次排序后arr=", (*arr))
    
}

func main() {
	arr := [5]int{24, 69, 80, 57, 13} //定义数组
	//将数组传递给一个函数，完成排序
	BubbleSort(&arr) //传入arr地址
}

代码完全体：

//冒泡排序

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.Printf("第%v次排序后arr=%v\n", i+1, (*arr))
	}

}

func main() {
	arr := [5]int{24, 69, 80, 57, 13} //定义数组
	//将数组传递给一个函数，完成排序
	BubbleSort(&arr) //传入arr地址

	fmt.Println("main arr=", arr) //传入的是地址，所以BubbleSort可以修改main函数里面的数组
}

二、查找

介绍：

在Golang 中，我们常用的查找有两种:

顺序查找
二分查找(该数组是有序)

1.顺序查找

案例演示：

有一个数列：白眉鹰王、金毛狮王、紫衫龙王、青翼蝠王

猜数游戏：从键盘中任意输入一个名称，判断数列中是否包含此名称【顺序查找】

func main() {
	/*
		有一个数列：白眉鹰王、金毛狮王、紫衫龙王、青翼蝠王
		猜数游戏：从键盘中任意输入一个名称，判断数列中是否包含此名称【顺序查找】
		思路：
		1.定义一个数组,白眉鹰王、金毛狮王、紫衫龙王、青冀蝠王  字符串数组
		2.从控制台接收一个名词，依次比较，如果发现有，提示
	*/

	name := [4]string{"白眉鹰王", "金毛狮王", "紫衫龙王", "青冀蝠王"}
	var heroName = ""
	fmt.Println("请输入人名：")
	fmt.Scanln(&heroName)

	//顺序查找：第一种方式
	for i := 0; i < len(name); i++ {
		if heroName == name[i] {
			fmt.Printf("第一种方式找到了%v\n", heroName)
			break //退出循环
		} else if i == len(name)-1 {
			fmt.Printf("第一种方式没有找到%v\n", heroName)
		}
	}

	//顺序查找：第二种方式（推荐使用第二种方式）
	index := -1

	for i := 0; i < len(name); i++ {
		if heroName == name[i] {
			index = i
			break
		}
	}
	if index != -1 {
		fmt.Printf("第二种方式找到了%v\n", heroName)
	} else {
		fmt.Printf("第二种方式没有找到%v\n", heroName)
	}
}

2.二分查找(该数组是有序)

请对一个有序数组进行二分查找{1,8, 10, 89, 1000, 1234} ，输入一个数看看该数组是否存

在此数，并且求出下标，如果没有就提示"没有这个数"。【会使用到递归】

二分查找的思路分析：

在这里插入图片描述

代码：

package main

import "fmt"

/*
arr=[1,8, 10, 89, 1000, 1234] 8
二分查找的思路:比如我们要查找的数是findVal
1. arr是一个有序数组，并且是从小到大排序

2.先找到中间的下标middle =(leftIndex+ rightIndex)/2,然后让中间下标的值和findVal进行比较
2.1如果 arr[middle] > findVal ,就应该向 leftIndex --- (middle-1)
2.2如果 arr[middle] < findVal ,就应该向 middle+1--- rightIndex
2.3如果 arr[middle] ==findVal 就找到
2.4.上面的2.12.22.3的逻辑会递归执行

3.想一下，怎么样的情况下，就说明找不到[分析出退出递归的条件!]
if leftIndex> rightindex{
//找不到..
return ..
}

*/

func BinaryFind(arr *[6]int, leftIndex int, rightIndex int, findVal int) { //返回最小至下标、最大值下标、中间值下标
	//由于是有序排序，而且是从小到大顺序排列
	//判断leftIndex是否大于rightIndex
	if leftIndex > rightIndex {
		fmt.Println("没找到值")
		return
	}

	middle := (leftIndex + rightIndex) / 2 //算出中间的下标

	//中间下标的值小于要寻找的值，说明要找的值在leftIndex 到 middle-1 之间
	if (*arr)[middle] > findVal {
		BinaryFind(arr, leftIndex, middle-1, findVal) //返回给函数BinaryFind参数并且再次执行
	} else if (*arr)[middle] < findVal { //中间下标的值大于于要寻找的值，说明要找的值在middle+1 到 rightIndex
		BinaryFind(arr, middle+1, rightIndex, findVal)
	} else {
		fmt.Printf("找到了%v,下标是[%v]", values, middle)
	}
}

var values int

func main() {
	fmt.Println("你要查找的值是多少：")
	fmt.Scanln(&values)

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

三、二维数组

1.二维数组的介绍

多维数组我们只介绍二维数组

2.二维数组的应用场景

比如我们开发一个五子棋游戏，棋盘就是需要二维数组来表示。如图

在这里插入图片描述

3.二维数组快速入门

快速入门案例：

请用二维数组输出如下图形

0 0 0 0 0 0
0 0 1 0 0 0
0 2 0 3 0 0
0 0 0 0 0 0

代码演示

func main() {
	/*
		请用二维数组输出如下图形
		0 0 0 0 0 0
		0 0 1 0 0 0
		0 2 0 3 0 0
		0 0 0 0 0 0
	*/

	//声明一个二维数组，表示有4行6列，默认值都为0
	var arr [4][6]int
	fmt.Println(arr) //输出[[0 0 0 0 0 0] [0 0 0 0 0 0] [0 0 0 0 0 0] [0 0 0 0 0 0]]

	//赋初始值
	arr[1][2] = 1
	arr[2][1] = 2
	arr[2][3] = 3
	fmt.Println(arr)

	//遍历二维数组，按照要求输出图形
	for i := 0; i < 4; i++ {
		for j := 0; j < 6; j++ {
			fmt.Print(arr[i][j], " ")
		}
		fmt.Println()
	}
}

4.使用方式1:先声明/定义,再赋值

语法: var 数组名 [大小][大小] 类型

比如: var arr [2][3]int ，再赋值。

使用演示

二维数组在内存的存在形式(重点)

在这里插入图片描述

	//二维数组在内存的布局
	var arr2 [2][3]int //以这个为例来分析arr2在内存的布局
	arr2[1][1] = 10
	fmt.Println(arr2)

	fmt.Printf("arr[0]的地址是%p\n", &arr2[0])
	fmt.Printf("arr[1]的地址是%p\n", &arr2[1])

5.使用方式2:直接初始化

声明：var 数组名[大小][大小]类型= [大小][大小]类型{{初值..},{初值..}}
赋值(有默认值，比如int 类型的就是0)
使用演示：

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

说明：二维数组在声明/定义时也对应有四种写法[和一维数组类似]

var 数组名[大小][大小]类型= [大小][大小]类型{{初值..},{初值..}}

var 数组名[大小][大小]类型= [...][大小]类型{{初值..},{初值..}}

var 数组名= [大小][大小]类型{{初值..},{初值..}}

var 数组名= [...][大小]类型{{初值..},{初值..}}

6.二维数组的遍历

双层for 循环完成遍历

for-range 方式完成遍历

案例演示：

func main() {
	//演示二维数组的遍历
	var arr3 [2][3]int = [2][3]int{{1, 2, 3}, {4, 5, 6}}

	//for循环遍历
	for i := 0; i < len(arr3); i++ { //len(arr3) = 2
		for j := 0; j < len(arr3[i]); j++ {
			fmt.Printf("%v\t", arr3[i][j])
		}
		fmt.Println()
	}

	//for-range来遍历
	for i, v := range arr3 {
		for i2, v2 := range v {
			fmt.Printf("arr[%v][%v]=%v \t", i, i2, v2)
		}
		fmt.Println()
	}
}

7.二维数组的应用案例

要求如下：

定义二维数组，用于保存三个班，每个班五名同学成绩，

并求出每个班级平均分、以及所有班级平均分

代码

func main() {
	//定义二维数组，用于保存三个班，每个班五名同学成绩，
	//并求出每个班级平均分、以及所有班级平均分

	//1.定义一个二维数组
	var scores [3][5]float64
	for i := 0; i < len(scores); i++ { //len(scores)有3个下标
		for j := 0; j < len(scores[i]); j++ { //len(scores[0])有5个下标
			fmt.Printf("请输入第%d班的第%d个学校成绩\n", i+1, j+1)
			fmt.Scanln(&scores[i][j])
		}
	}
	fmt.Println(scores)

	totalSum := 0.0 //定义一个变量，用户累计所有班级的总分
	//遍历结果
	for i := 0; i < len(scores); i++ {
		sum := 0.0 //定义一个变量，用于累计各个班级的总分
		for j := 0; j < len(scores[i]); j++ {
			sum += scores[i][j]
		}
		totalSum += sum
		fmt.Printf("第%d班级的总分为%v,平均分为%v\n", i+1, sum, sum/float64(len(scores[i])))
	}
	fmt.Printf("所有班级的总分为%v,所有班级平均分为%v\n", totalSum, totalSum/15)
}