本篇文章是在<<go 冒泡排序>>基础之上进行的优化。
上面文章的代码：

image

1、代码优化

利用go语言中函数特性，可以作为参数进行传递 进行代码优化
源码如下：

package main

import "fmt"

type sortF func(int, int) bool

func sort(arr []int, f sortF) []int {

    for i := 0; i < len(arr)-1; i++ {
        for j := 0; j < len(arr)-1-i; j++ {
            if f(arr[j], arr[j+1]) {
                arr[j], arr[j+1] = arr[j+1], arr[j]
            }
        }
    }

    return arr
}

// 如果按照从小到大排序
// 那么，相邻两个数(前后两个数)交换的条件是
// 前面的数，大于了， 后面的数，
// 需要进行交换了
func sortBySmall(a, b int) bool {
    return a > b
}

// 如果按照从大到小排序
// 那么，相邻两个数(前后两个数)交换的条件是
// 前面的数，小于了， 后面的数，
// 需要进行交换了
func sortByBig(a, b int) bool {
    return a < b
}

func main() {
    data := []int{6, 5, 4, 2, 9, 1, 0, 4, 2, 3, 11}

    sort(data, sortByBig)

    for _, d := range data {
        fmt.Printf("%d ", d)
    }

    fmt.Println()
}

将从小到大函数和从大到小函数进行合并

关于链式处理思路，可以参考这篇

Go语言字符串的链式处理——操作与数据分离的设计技巧

2、测试

函数作为参数进行传递

  
  
  
  

打赏