[go学习笔记.第八章.排序和查找] 1.排序,查找的基本介绍

一.排序

1.概念

排序是将一组数据,依指定的顺序进行排列的过程.

2.排序的分类

(1).内部排序

        指将需要处理的所有数据都加载到内部存储器中进行排序.包括:交换式排序法,选择式排序法和插入式排序法

(2).外部排序

        数据量过大,无法全部加载到内存中,需要借助外部存储进行排序.包括:合并排序法和直接合并排序法  

3.交换式排序法

交换式排序属于内部排序,是运用数据值比较后,依判断规则对数据位置进行交换,以达到排序的目的,交换式排序分两种:

(1).冒泡排序法(Bubble sort)

(2).快速排序法(Quick sort)

4. 交换式排序法-冒泡排序法

基本思路:

        通过对待排序序列从后到前(从下标较大的元素开始),依次比较相邻元素的排序码,若发现逆序则交换,使排序码较小的元素逐渐从后部移向前部(从下标较大的单元移向下标较小的单元),就像水底下的气泡一样,逐渐向上冒.

        因为排序过程中,各元素不断接近自己的位置,如果一趟下来没有进行交换,就说明序列有序,因此要在排序过程中设置一个标志flag判断元素是否进行过交换,从而减少不必要的比较 

 

 案例:

        将五个无序的数:24, 69, 80, 57, 13 使用冒泡排序法将其排成一个从小到大的有序序列

package main

import (
    "fmt"
)

// 冒泡排序
func bubleSort (arr *[5]int)  {
    fmt.Println("排序前arr= ", (*arr)) //排序前arr=  [12 34 3 88 65]
    temp := 0 //临时变量
    //第一轮排序
    for i := 0; i < 4; i++ {
            if (*arr)[i] > (*arr)[i + 1] {
                temp = (*arr)[i]
                (*arr)[i] = (*arr)[i + 1]
                (*arr)[i + 1] = temp
            }
    }

    fmt.Println("第一轮排序后arr= ", (*arr))  //第一轮排序后arr=  [12 3 9 5 88]

    //第二轮排序
    for i := 0; i < 3; i++ {
        if (*arr)[i] > (*arr)[i + 1] {
            temp = (*arr)[i]
            (*arr)[i] = (*arr)[i + 1]
            (*arr)[i + 1] = temp
        }
    }

    fmt.Println("第二轮排序= ", (*arr))  //第二轮排序=  [3 9 5 12 88]
    // ...

    //升级成冒泡排序
    for j := 0; j < len(*arr) - 1; j++ {
        for i := 0; i < len(*arr) - 1 - j; i++ {
            if (*arr)[i] > (*arr)[i + 1] {
                temp = (*arr)[i]
                (*arr)[i] = (*arr)[i + 1]
                (*arr)[i + 1] = temp
            }
        }
    }

    fmt.Println("冒泡排序后= ", (*arr))  // 冒泡排序后=  [3 5 9 12 88]
}

func main() {
    //定义个数组
    arr := [5]int{12, 88, 3, 9, 5}
    //把数组传给一个函数
    bubleSort(&arr)
    fmt.Println("冒泡排序后= ", arr) //冒泡排序后=  [3 5 9 12 88]
}

二.查找

1.介绍

在go语言中,常用到两种查找:

(1).顺序查找

(2).二分查找(前提:数组是有序的)

 2.案例演示

顺序查找

package main

import (
    "fmt"
)

func main()  {
    //有一个数列: 张三,李四,王五,赵六
    //猜:从键盘输入一个名称,判断数列中是否包含此名称[顺序查找]
    //思路:
    //定义一个数组:张三,李四,王五,赵六
    //2.从控制台输入一个名称,一依次比较,如果发现存在,则提示
    
    name := [4]string{"张三","李四","王五","赵六"}
    var heroName = ""
    fmt.Println("请输入要查找的名字:")
    fmt.Scanln(&heroName)

    //顺序查找:方式一
    for i := 0; i < len(name); i++ {
        if heroName == name[i] {
            fmt.Printf("找到了, 下标为:%v\n", i)
            break
        } else if i == len(name) -1 {
            fmt.Printf("没找到\n")
        }
    }
  
    //顺序查找:方式二(推荐使用)
    index := -1
    for i := 0; i < len(name); i++ {
        if heroName == name[i] {
            index = i //将找到的值对应的下标赋给index
            break
        }
    }

    if index != -1 {
        fmt.Printf("找到了, 下标为:%v\n", index)
    } else {
        fmt.Printf("没找到\n")
    }
}

二分查找 

package main

import (
	"fmt"
)

//二分查找的函数
/**
二分查找的思路分析: 需要查找的数是 findValue
1.arr是一个有序的数组,从小到大排序
2.先找到中间的下标middleIndex = (leftIndex + rightIndex) / 2, 然后让中间下标的值和findValue比较
2.1 如果arr[middleIndex] > findValue, 就应该向 leftIndex ~ middleIndex - 1方向查找
2.2 如果arr[middleIndex] < findValue, 就应该向 middleIndex + 1 ~ rightIndex 方向查找
2.3 如果arr[middleIndex] = findValue, 就找到了
2.4 上面的逻辑 2.1,2.2, 2.3 会递归执行
3.思考一下: 什么情况下就找不到了[分析出退出递归的条件]
if leftIndex > rightIndex {
	//找不到
	return ...
}
*/

func BinaryFind(arr *[6]int, leftIndex int, rightIndex int, findValue int) {
	//判断leftIndex是否大于rightIndex
	if leftIndex > rightIndex {
		fmt.Printf("没有找到\n")
		return
	}
	//先找到中间的下标
	middleIndex := (leftIndex + rightIndex) / 2
	if (*arr)[middleIndex] > findValue {
		//说明要查找的数在leftIndex ~ middleIndex - 1 之间
		BinaryFind(arr, leftIndex, middleIndex - 1, findValue)
	} else if (*arr)[middleIndex] < findValue {
		//说明要查找的数在middleIndex + 1 ~ rightIndex 之间
		BinaryFind(arr, middleIndex + 1, rightIndex, findValue)
	} else {
		fmt.Printf("找到了, 下标为: %v\n", middleIndex)
	}
}

func main() {
	arr := [6]int{1, 5, 8, 10, 23, 88}
	//测试
	BinaryFind(&arr, 0, len(arr) -1 , 23)	//找到了, 下标为: 4
}

[上一节][go学习笔记.第七章.数组和切片] 5.slice和string

[下一节][go学习笔记.第八章.排序和查找] 2.二维数组