一．排序
1.排序的介绍
排序是将一群数据，依指定的顺序进行排列的过程。
排序的分类：
（1）内部排序
将需要处理的所有数据都加载到内部存储器中进行排序。
包括（交换式排序，选择式排序和插入式排序）
（2）外部排序
数据量过大，无法全部加载到内存中，需要借助外部存储进行排序。
包括（合并排序法和直接合并排序法）
交换式排序法
交换式排序属于内部排序，是运用数据值比较后，依赖判断则对数据位置进行交换，以达到排序的目的。
交换式排序法又可分为两种：
<1>冒泡排序法（Bubble sort）
<2>快速排序法（Quick sort）
冒泡排序的基本思想是：通过对待排序从后向前（从下标较大的元素开始），依次比较相邻元素的排序码，若发现逆序则交换，使排序较小的元素逐渐从后部向前部（从下标较大的单元移向下标较小的单元），就像水底的气泡一样逐渐向上冒。
因为排序的过程中，各元素不断接近自己的位置，如果一趟比较下来没有进行过交换，就说明序列有序，因此要在排序过程中设置一个标志flag判断元素是否进行过交换。从而减少不必要的比较（优化）。
冒泡排序案例：
举例说明冒泡法。
24,69,80,57,13
第一轮比较：
第一次比较为第一个元素和第二个元素比较，如果前面的元素大于后面的元素则交换，否则不动。
24,69,80,57,13
第二次比较为第二个元素和第三个元素比较，如果前面的元素大于后面的元素则交换，否则不动。
24,69,80,57,13
第三次比较为第三个元素和第四个元素比较，如果前面的元素大于后面的元素则交换，否则不动。
24,69,57,80,13
第四次比较为第四个元素和第五个元素比较，如果前面的元素大于后面的元素则交换，否则不动。
24,69,57,13,80
第一轮结束，得到最后一个元素为这组数的最大值。
第二轮以第一轮的方式进行比较。
如果第一轮比较n次，第二轮则只需要比较n-1次，依次减少。
总结：
1.一共arr.length-1次的轮数比较，每一轮将会确定一个数的位置。
2.每一轮比较次数在逐渐减少。
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() {
// 定义数组
arr := [5]int{24, 69, 80, 57, 13}
// 将数组传递给一个函数，完成排序
BubbleSort(&arr)
}
二．查找
介绍：
在Golang中，我们常用的查找有两种
1.顺序查找
举例：
package main
import "fmt"
func main() {
// 白色 金色 紫色 青色
// 判断输入的颜色是都存在数组中
// 思路：
// 1.定义一个数组 白色 金色 紫色 青色
//2.从控制台接收一个名词，依次比较，如发现有，提示
colors := [4]string{"白色", "金色", "紫色", "青色"}
var color = ""
// 顺序查找第一种方式
fmt.Println("请输入一个颜色：")
fmt.Scanln(&color)
for i := 0; i < len(colors); i++ {
if color == colors[i] {
fmt.Println("找到了颜色：", color)
} else if i == (len(colors) - 1) {
fmt.Println("没有找到")
}
}
// 顺序查找第二种方式
index := -1
for i := 0; i < len(colors); i++ {
if color == colors[i] {
index = i // 将找到的值对应的下标赋给index
break
}
}
if index != -1 {
fmt.Println("找到了", color, index)
} else{
fmt.Println("没有找到")
}
}
2.二分查找（该数组前提有序）
举例：请对一个有序的数组arr = [1,8,10,1000,1234]
二分查找的思路:比如要查找findval
1.arr是一个有序数组，并且是从小到大排序
2.先找到中间的下标mid = (leftindex + rightindex) / 2,然后让中间下标的值和findval进行比较
2.1 如果arr[mid] > findval,就应该leftindex -----(mid-1)
2.2如果arr[mid] < findval ，就应该mid + 1 ---- rightindex
2.3如果arr[mid] == findval，就找到
2.4上面的2.1 2.2 2.3的逻辑递归执行
3.想一下，怎么样的情况下，就说明找不到分析出退出递归的条件
if leftindex > rigthindex {
// 找不到
return
}
举例二分法代码：
package main
import (
"fmt"
)
// 二分查找
/*
二分查找的思路:比如要查找findval
1.arr是一个有序数组，并且是从小到大排序
2.先找到中间的下标mid = (leftindex + rightindex) / 2,然后让中间下标的值和findval进行比较
2.1 如果arr[mid] > findval,就应该leftindex -----(mid-1)
2.2如果arr[mid] < findval ，就应该mid + 1 ---- rightindex
2.3如果arr[mid] == findval，就找到
2.4上面的2.1 2.2 2.3的逻辑递归执行
3.想一下，怎么样的情况下，就说明找不到分析出退出递归的条件
*/
func BinarySort(arr *[6]int, leftIndex int, rightIndex int, findVal int) {
// 判断leftIndex 是否大于rightIndex
if leftIndex > rightIndex {
fmt.Println("找不到")
return
}
// 中间的下标
mid := (leftIndex + rightIndex) / 2
if (*arr)[mid] > findVal {
// 说明要查找的数，应该在left leftIndex --- mid -1
BinarySort(arr, leftIndex, mid-1, findVal)
} else if (*arr)[mid] < findVal {
// 说明要查找的数，应该在left mid + 1 ---- rightIndex
BinarySort(arr, mid+1, rightIndex, findVal)
} else {
// 找到了
fmt.Printf("下标为%v", mid)
}
}
func main() {
//
arr := [6]int{1, 8, 10, 89, 1000, 1234}
BinarySort(&arr, 0, len(arr)-1, 1000)
}