GO语言实现冒泡排序、顺序查找、二分查找

package main

import "fmt"

func main() {
    arr := [5]int{23, 56, 2, 117, 88} // 创建一个长度为5的整型数组arr，并赋值
    fmt.Println(arr)                  // 打印arr数组
    BubbleSort(&arr)                  // 调用BubbleSort函数对arr进行排序
    fmt.Println("sort:", arr)         // 打印排序后的arr数组
    //SequentialLookup() // 调用SequentialLookup函数
    fmt.Println("------------------------------") // 打印分隔线

    arrs := [10]int{1, 23, 45, 78, 90, 115, 456, 980, 1000, 1200} // 创建一个长度为10的整型数组arrs，并赋值
    search := binarySearch(arrs, 1)                               // 调用binarySearch函数在arrs中搜索元素1，并将结果赋值给search
    if search == -1 {                                             // 如果search为-1
       fmt.Println("不存在") // 打印"不存在"
    } else {
       fmt.Println(search) // 打印search
    }

    BinaryFind(&arrs, 0, len(arrs)-1, 15) // 调用BinaryFind函数在arrs中查找元素15
}

// BubbleSort 冒泡排序函数
func BubbleSort(arr *[5]int) {
    for i := 0; i < len(*arr)-1; i++ {
       swap := false // 判断是否交换
       for j := 0; j < len(*arr)-1-i; j++ {
          if (*arr)[j] > (*arr)[j+1] { // 如果arr[j]大于arr[j+1]
             (*arr)[j], (*arr)[j+1] = (*arr)[j+1], (*arr)[j] // 交换arr[j]和arr[j+1]
             swap = true                                     // 将swap设为true
          }
       }
       if !swap { // 如果没有发生交换
          break // 跳出循环
       }
    }
}

// 顺序查找函数
func SequentialLookup() {
    names := [5]string{"JOJO", "Tom", "打怪", "小怪", "lyrics"} // 创建一个长度为5的字符串数组names，并赋值
    var yourName string                                     // 创建一个字符串变量yourName
    fmt.Scanln(&yourName)                                   // 从命令行读取yourName的值
    index := -1                                             // 创建一个整型变量index，并赋值为-1
    for i := 0; i < len(names); i++ {                       // 遍历names数组
       if yourName == names[i] { // 如果yourName等于names[i]
          index = i // 将index设为i
       }
    }

    if index != -1 { // 如果index不等于-1
       fmt.Println("找到", yourName) // 打印"找到"和yourName
    } else {
       fmt.Println("没找到", index, yourName) // 打印"没找到"、index和yourName
    }
}

// 二分查找函数
func binarySearch(arrs [10]int, key int) int {
    left := 0              // 搜索范围左边界
    right := len(arrs) - 1 // 搜索范围右边界
    for right >= left {    // 当右边界大于等于左边界时
       mid := left + (right-left)/2 // 计算中间值的索引
       if arrs[mid] == key {        // 如果中间值等于key
          return mid // 返回中间值的索引
       }
       if key > arrs[mid] { // 如果key大于中间值
          left = mid + 1 // 将左边界设为mid+1
       } else {
          right = mid - 1 // 将右边界设为mid-1
       }
    }
    return -1 // 返回-1表示未找到
}

// BinaryFind 二分查找递归实现函数
func BinaryFind(arr *[10]int, left, right, key int) {
    if left > right { // 如果左边界大于右边界
       fmt.Println("不存在", key) // 打印"不存在"和key
       return                  // 结束函数
    }
    mid := (left + right) / 2 // 计算中间值的索引
    if key > (*arr)[mid] {    // 如果key大于中间值
       // 在右边查找
       BinaryFind(arr, mid+1, right, key)
    } else if key < (*arr)[mid] { // 如果key小于中间值
       // 在左边查找
       BinaryFind(arr, left, mid-1, key)
    } else {
       // arr[mid]==key
       fmt.Println("找到了值：", key, " ", mid) // 打印"找到了值："、key和mid
    }
}

快速排序

func quickSort(arr []int) {
	// 结束条件
	if len(arr) < 2 {
		return
	}
	left, right := 0, len(arr)-1
	// 选取最后元素为基准
	pivot := right
	// 将小于基准的元素放到左边，大于基准的元素放到右边
	for i := range arr {
		if arr[i] < arr[pivot] {
			arr[left], arr[i] = arr[i], arr[left]
			left++
		}
	}
	arr[left], arr[pivot] = arr[pivot], arr[left]

	quickSort(arr[:left])
	quickSort(arr[left+1:])
}