GO学习笔记 排序和查找

一．排序

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)
}