排序基本介绍
排序是将一组数据，依指定的顺序进行排列的过程
排序分类
- 内部排序
指将需要处理的所有数据都加载到内存中进行排序
包括（交换式排序法、选择式排序法和 插入式排序法） - 外部排序法
数据量过大，无法全部加载到内存中，需要借助外部存储进行排序
包括（合并排序法和直接合并排序法）
冒泡排序
冒泡排序（Bubble Sorting）的基本思想：通过对待排序序列从后向前（从下标较大的元素开始），依次比较相邻元素的排序码，若发现逆序则交换，使排序码较小的元素逐渐从后部移向前部（从下标较大的单元移向下标较小的单元），就像水底下的气泡一样逐渐向上冒
因为排序的过程中，各元素不断接近自己的位置，如果一趟比较下来没有进行过交换，就说明序列有序，因此要在排序过程中设置一个标志flag判断元素是否进行过交换。从而减少不必要的比较（优化）
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
}
}
}
}
func main() {
arr := [5]int{24, 69, 80, 57, 13}
BubbleSort(&arr)
fmt.Println("arr=", arr)
}
查找
在golang中，我们常用的查找有两种：
- 顺序查找
- 二分查找（该数组是有序）
案例：
- 有一个数列： 白眉鹰王、金毛狮王、紫衫龙王、青冀蝠王
猜数游戏：从键盘中任意输入一个名称，判断数列中是否包含此名称【顺序查找】
package main
import "fmt"
func main() {
names := [4]string{"白眉鹰王", "金毛狮王", "紫衫龙王", "青冀蝠王"}
var heroName = ""
fmt.Println("请输入要查找的人名： ")
fmt.Scanln(&heroName)
for i := 0; i < len(names); i++ {
if heroName == names[i] {
fmt.Printf("找到%v, 下标%v", heroName, i)
break
}
if i == len(names) -1 {
fmt.Printf("没有找到%v \n", heroName)
}
}
}
package main
import "fmt"
func main() {
names := [4]string{"白眉鹰王", "金毛狮王", "紫衫龙王", "青冀蝠王"}
var heroName = ""
fmt.Println("请输入要查找的人名： ")
fmt.Scanln(&heroName)
index := -1
for i := 0; i < len(names); i++ {
if heroName == names[i] {
index = i
break
}
}
if index == -1 {
fmt.Printf("没有找到%v \n", heroName)
} else {
fmt.Printf("找到%v , 下标%v \n", heroName, index)
}
}
- 请对一个有序数组进行二分查找{1, 8, 10, 89, 1000, 1234}, 输入一个数看看该数组是否存在此数，并且求出下标，如果没有就提示"没有这个数"
middle := (leftIndex + rightIndex) / 2
arr[middle] > findVal —> leftIndex – middle -1
arr[middle] < findVal —> middle + 1 – rightIndex
arr[middle] == findVal 找到了
if leftIndex > rightIndex 找不到
package main
import "fmt"
func BinaryFind(arr *[6]int, leftIndex int, rightIndex int, findVal int) {
if leftIndex > rightIndex {
fmt.Println("找不到")
return
}
middle := (leftIndex + rightIndex) / 2
if (*arr)[middle] > findVal {
BinaryFind(arr, leftIndex, middle - 1, findVal)
} else if (*arr)[middle] < findVal {
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, 8)
}
二维数组
package main
import "fmt"
func main() {
var arr [4][6]int
arr[1][2] = 1
arr[2][1] = 2
arr[2][3] = 3
for i :=0; i < 4; i++ {
for j := 0; j < 6; j++ {
fmt.Print(arr[i][j], " ")
}
fmt.Println()
}
}
运行结果
0 0 0 0 0 0
0 0 1 0 0 0
0 2 0 3 0 0
0 0 0 0 0 0
使用方式1： 先声明/定义，再赋值
语法
var 数组名 [大小][大小]类型
var arr [2][3]int
package main
import "fmt"
func main() {
var arr2 [2][3]int
arr2[1][1] = 10
fmt.Println(arr2)
fmt.Printf("arr2的地址%p\n", &arr2)
fmt.Printf("arr2[0]的地址%p\n", &arr2[0])
fmt.Printf("arr2[1]的地址%p\n", &arr2[1])
fmt.Printf("arr2[0][0]的地址%p\n", &arr2[0][0])
fmt.Printf("arr2[1][0]的地址%p\n", &arr2[1][0])
}
使用方式2： 直接初始化
var 数组名 [大小][大小]类型 = [大小][大小]类型{{初值...},{初值...}}
var 数组名 [大小][大小]类型 = [...][大小]类型{{初值...},{初值...}}
var 数组名 = [大小][大小]类型{{初值...},{初值...}}
var 数组名 = [...][大小]类型{{初值...},{初值...}}
//默认值 int类型就是 0
package main
import "fmt"
func main() {
var arr3 [2][3]int = [2][3]int{{1, 2, 3}, {4, 5, 6}}
fmt.Println("arr3=", arr3)
}
二维数组的遍历
package main
import "fmt"
func main() {
var arr3 [2][3]int = [2][3]int{{1, 2, 3}, {4, 5, 6}}
for i := 0; i < len(arr3); i++ {
for j := 0; j <len(arr3[i]); j++ {
fmt.Printf("%v\t", arr3[i][j])
}
fmt.Println()
}
for i, v := range arr3{
for j, v2 := range v {
fmt.Printf("arr3[%v][%v]=%v ", i, j, v2)
}
fmt.Println()
}
}
定义二维数组，用于保存三个班，每个班五名同学的成绩，并求出每个班平均分、以及所有班级平均分
package main
import "fmt"
func main() {
var scores [3][5]float64
for i := 0; i < len(scores); i++ {
for j := 0; j < len(scores[i]); j++ {
fmt.Printf("请输入第%v班的第%v个学生的成绩：\n", i + 1, j + 1)
fmt.Scanln(&scores[i][j])
}
}
totolSum := 0.0
for i := 0; i < len(scores); i++ {
sum := 0.0
for j := 0; j < len(scores[i]); j++ {
sum += scores[i][j]
}
totolSum += sum
fmt.Printf("第%v班的平均成绩为%v\n", i + 1, sum / float64(len(scores[i])))
}
fmt.Printf("所有班的平均成绩为%v\n", totolSum / 3)
}
