8.1 排序的介绍
排序是将一群数据，依指定的顺序进行排列的过程
8.2 排序的分类：
1、内部排序
指将需要处理的所有数据都加载到内部存储器中进行排序，包括(交换式排序法，选择式排序法和插入式排序法)
2、外部排序法
数据量过大，无法全部加载到内存中，需要借助外部存储进行排序，包括(合并排序法和直接合并排序法)
8.3 交换式排序
交换式排序属于内部排序法，是运用数值比较后，依判断规则对数据位置进行交换，以达到排序的目的
交换式排序又可分为两种：
1、冒泡排序法(Bubble sort)
2、快速排序法(Quick sort)
冒泡排序的基本思想是：通过对待排序序列从后向前(从下标比较大的元素开始)，一次比较相邻元素的序码，若发现逆序则交换，使排序码较小的元素逐渐从后部移向前部(从下标比较大的单元移向下标较小的单元)，就像水底下的气泡一样逐渐向上冒
因为排序的过程中，各元素不断接近自己的位置，如果一趟比较下来没有进行过交换，就说明排序有序，因此要在排序过程中设置一个标志flag判断元素是否进行过交换。从而减少不必要的比较(优化)。
8.4 冒泡排序法案例
24、69、80、57、13使用冒泡排序法将其排成一个从小到大的有序数列
8.5 冒泡排序代码实现
最终实现方法
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() {
// 定义数组
arr := [5]int{24,69,80,57,13}
// 将数组传递给一个函数，完成排序
BubbleSort(&arr)
fmt.Println("main arr=", arr)
}
第一次冒泡排序代码
package main
import (
"fmt"
)
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("第一次排序后arr=", (*arr))
}
func main() {
// 定义数组
arr := [5]int{24,69,80,57,13}
// 将数组传递给一个函数，完成排序
BubbleSort(&arr)
// fmt.Println("main arr=", arr)
}
第二次冒泡排序
package main
import (
"fmt"
)
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("第一次排序后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("第二次排序后arr=", (*arr))
}
func main() {
// 定义数组
arr := [5]int{24,69,80,57,13}
// 将数组传递给一个函数，完成排序
BubbleSort(&arr)
// fmt.Println("main arr=", arr)
}
8.6 查找
介绍
在Golang中，我们常用的查找有两种：
- 顺序查找
- 二分查找 (数组是有序的)
案例演示
- 有一个数列：白眉鹰王、金毛狮王、紫衫龙王、青翼蝠王，从键盘输入一个名称，判断数列中是否包含此名称
package main
import (
"fmt"
)
func main() {
// 思路
// 1、定义一个数组
// 2、从控制台接收一个名词，依次比较，如果发现有，提示
names := [4]string{"白眉鹰王","金毛狮王","紫衫龙王","青翼蝠王"}
var heroName = ""
fmt.Println("请输入要查找的人名：")
fmt.Scanln(&heroName)
// 顺序查找第一种方式
for i := 0; i < len(names); i++ {
if heroName == names[i] {
fmt.Printf("1-找到了%v，下标为%v
", heroName, i)
break
} else if i == len(names) - 1 {
fmt.Printf("1-没有找到%v
", heroName)
}
}
// 顺序查找第2种方式
index := -1
for i := 0; i < len(names); i++ {
if heroName == names[i] {
index = i //将找到的值对应的下标赋给 index
break
}
}
if index != -1 {
fmt.Printf("2-找到了%v，下标为%v
", heroName, index)
} else {
fmt.Println("2-没有找到", heroName)
}
}
- 请求一个有序数组进行二分查找{1.8, 10, 89, 1000,1234} 输入一个数看看该数是否存在此数，并且求出下标，如果没有就提示“没有这个数”
分析图
代码
package main
import (
"fmt"
)
/*
二分查找的思路: 比如我们要查找的数是 findVal
1. arr是一个有序数组，并且是从小到大排序
2. 先找到 中间的下标 middle = (leftIndex + rightIndex) / 2, 然后让 中间下标的值和findVal进行比较
2.1 如果 arr[middle] > findVal , 就应该向 leftIndex ---- (middle - 1)
2.2 如果 arr[middle] < findVal , 就应该向 middel+1---- rightIndex
2.3 如果 arr[middle] == findVal ， 就找到
2.4 上面的 2.1 2.2 2.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
if (*arr)[middle] > findVal {
// 说明 我们要查找的，应该在 leftIndex --- middel-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
", middle)
}
}
func main() {
arr := [6]int{1, 8, 10, 89, 1000, 1234}
BinaryFind(&arr, 0, len(arr) - 1, 1000)
// &arr是地址，因为上面的BiinaryFind接收的是一个指针
// 0, len(arr) - 1 表示是从下标为0 到这个数组的数组长度-1(即就是最后一个元素)
// 1 表示要具体查找的元素值 这里是1000
}
8.7 二维数组
8.7.1 使用方式1：先声明/定义再赋值
1、语法：var 数组名[大小] [大小] 类型
2、比如：var arr[2] [3]int[] [] 再赋值
3、使用演示 
4、二维数组在内存的存在形式(重点)
8.7.2 使用方式2：直接初始化
1、声明：var 数组名[大小] [大小]类型 = [大小] [大小]类型{{初值...},{初值...}}
2、赋值(有默认值，比如int 类型就是0)
3、使用演示：
4、说明：二维数组在声明/定义时也对应有四种写法[和一维数组类似]
- var 数组名[大小] [大小]类型 = [大小] [大小]类型{{初值...},{初值...}}
- var 数组名[大小] [大小]类型 = [...]类型{{初值...},{初值...}}
- var 数组名 = [大小] [大小]类型{{初值...},{初值...}}
- var 数组名 = [...] [大小]类型{{初值...},{初值...}}
8.7.3 二维数组的遍历
1、双层for循环完成遍历
2、for-range方式完成遍历
8.7.4 二维数组的应用案例
定义二维数组，用于保存三个班，每个班5名同学成绩，并求出每个班级平均分，以及所有班级平均分
package main
import (
"fmt"
)
func main() {
// 1、定义一个二维数组
var scores [3][5]float64
// 2、循环输入成绩
for i := 0; i < len(scores); i++ {
for j := 0; j < len(scores[i]); j++ {
fmt.Printf("请输入第%d班的第%d个学生的成绩
", i+1, j+1)
fmt.Scanln(&scores[i][j])
}
}
fmt.Println(scores)
// 3、遍历输出成绩后的二维数组，统计平均分
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
",
i+1, sum, sum / float64(len(scores[i])))
}
fmt.Printf("所有班级的总分为%v，所有班级的平均分为%v
", totalSum, totalSum / 15)
}
结果为
