Golang——排序和查找

冒泡排序

//冒泡排序(asc)
package main
import(
	"fmt"
)
func main() {
	a:=[]int{24,69,80,57,13,24} //注意重复情况
	lenth:=len(a)
	for i:=0;i<lenth-1;i++{ //最多lenth-1趟
		for j:=0;j<lenth-1-i;j++{
			if a[j]>a[j+1] {
				temp:=a[j]
				a[j]=a[j+1]
				a[j+1]=temp
			}
		}
	}
	fmt.Println(a)

}

顺序查找

较为简单，遍历查询即可，故仅贴出代码

func sequentialSearch1(){//顺序查找：第一种方式
	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\n",heroName,i)
			break
		}else if i ==(len(names)-1){
			fmt.Printf("没有找到%w\n",heroName)
		}
	}
}
func sequentialSearch2(){//顺序查找：第二种方式
	index :=-1
	for i:=0;i<len(names);i++{
		if heroName =names[i]{
			index=i //将找到的值对应的下标赋给index
			break
		}
	}
	if index I=-1{
		fmt.Printf("找到%v,下标%v\n",heroName,index)
	}else{
	fmt.Println("没有找到",heroName)
	}
}
func main() {
	var choice int
	fmt.Scanln("1.顺序查找方法1，2.方法2",&choice)
	switch choice{
		choice==1:sequentialSearch1()
		choice==2:sequentialSearch2()
	}
}

二分查找

使用for循环 重复查找过程：
(LeetCode 704.二分查找）

//二分查找
func search(nums []int, target int) int {
    left,right:=0,len(nums)-1
    for left<=right{
        middle :=(left+right)/2
        if nums[middle]>target{
            right=middle-1
        }else if nums[middle]==target{
            return middle
        }else{
            left=middle+1
        }
    }
    return -1
}

以函数的形式使用二分查找，用到了递归的思想：

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 {
		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, -6)//test
}

再来一道LeetCode 374.猜数字大小

func guessNumber(n int) int {
    low,high:=0,n
    for low<=high{
        mid:=(low+high)/2
        switch guess(mid){
            case 0:return mid
            case -1:high=mid-1
            case 1:low=mid+1
        }
    }
    return 0
}

官方的题解。。直接调用二分函数：

func guessNumber(n int) int {
    return sort.Search(n, func(x int) bool { return guess(x) <= 0 })
}

sort包中的Search函数：

func Search(n int, f func(int) bool) int

Search函数采用二分法搜索找到[0, n)区间内最小的满足f(i)==true的值i。也就是说，Search函数希望f在输入位于区间[0, n)的前面某部分（可以为空）时返回假，而在输入位于剩余至结尾的部分（可以为空）时返回真；Search函数会返回满足f(i)==true的最小值i。如果没有该值，函数会返回n。注意，未找到时的返回值不是-1，这一点和strings.Index等函数不同。Search函数只会用区间[0, n)内的值调用f。

一般使用Search找到值x在插入一个有序的、可索引的数据结构时，应插入的位置。这种情况下，参数f（通常是闭包）会捕捉应搜索的值和被查询的数据集。

例如，给定一个递增顺序的切片，调用Search(len(data), func(i int) bool { return data[i] >= 23 })会返回data中最小的索引i满足data[i] >= 23。如果调用者想要知道23是否在切片里，它必须另外检查data[i] == 23。

搜索递减顺序的数据时，应使用<=运算符代替>=运算符。

下列代码尝试在一个递增顺序的整数切片中找到值x：

x := 23
i := sort.Search(len(data), func(i int) bool { return data[i] >= x })
if i < len(data) && data[i] == x {
	// x is present at data[i]
} else {
	// x is not present in data,
	// but i is the index where it would be inserted.
}

一个更古怪的例子，下面的程序会猜测你持有的数字：

func GuessingGame() {
	var s string
	fmt.Printf("Pick an integer from 0 to 100.\n")
	answer := sort.Search(100, func(i int) bool {
		fmt.Printf("Is your number <= %d? ", i)
		fmt.Scanf("%s", &s)
		return s != "" && s[0] == 'y'
	})
	fmt.Printf("Your number is %d.\n", answer)
}