zoukankan      html  css  js  c++  java
  • 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)
    }
    
  • 相关阅读:
    02 小白新一天
    集合排序
    匿名内部类-Lambda表达式
    设计模式之适配器设计
    设计模式之代理设计
    设计模式之工厂设计
    依赖倒转原则
    多态及练习题
    在一个类中调用另外一个类
    对象的三大特性之封装
  • 原文地址:https://www.cnblogs.com/hszstudypy/p/13598981.html
Copyright © 2011-2022 走看看