冒泡排序

冒泡排序详解

最新推荐文章于 2025-09-07 14:59:51 发布

very_loong

最新推荐文章于 2025-09-07 14:59:51 发布

阅读量318

点赞数

CC 4.0 BY-SA版权

分类专栏： golang 文章标签：算法冒泡排序

本文链接：https://blog.youkuaiyun.com/very_loong/article/details/77806762

golang 专栏收录该内容

4 篇文章

订阅专栏

冒泡排序是一种用于对存储器中给出的N个元素进行排序的算法，例如：具有N个元素的数组。冒泡排序将逐个比较所有元素，并根据它们的值进行排序。

它被称为冒泡排序，是因为每次迭代，列表中最大的元素向上浮起来，就像一个水泡上升到水面。

通过遍历所有数据项进行排序，并比较相邻的数据项和交换出错的每对数据。

这里写图片描述

下面列出golang实现的冒泡排序法：

package sort

func BubbleSort1(list []int) ([]int, int) {
    count := 0
    for i := 0; i < len(list); i++ {
        for j := i + 1; j < len(list); j++ {
            count++
            if list[i] > list[j] {
                list[i], list[j] = list[j], list[i]
            }
        }
    }
    return list, count
}

func BubbleSort2(list []int) ([]int, int) {
    count := 0
    for i := 1; i < len(list); i++ {
        for j := 0; j < len(list)-i-1; j++ {
            count++
            if list[j] > list[j+1] {
                list[j], list[j+1] = list[j+1], list[j]
            }
        }
    }
    return list, count
}

func BubbleSort3(list []int) ([]int, int) {
    count := 0
    flag := true
    for i := 1; i < len(list) && flag; i++ {
        flag = false
        for j := 0; j < len(list)-i-1; j++ {
            count++
            if list[j] > list[j+1] {
                list[j], list[j+1] = list[j+1], list[j]
                flag = true
            }
        }
    }
    return list, count
}

sort git:(dev) go test -v bubble_sort_test.go bubble_sort.go
=== RUN   TestBubbleSort1
--- PASS: TestBubbleSort1 (0.00s)
    bubble_sort_test.go:10: [5 10 20 21 33 56] 15
=== RUN   TestBubbleSort2
--- PASS: TestBubbleSort2 (0.00s)
    bubble_sort_test.go:14: [5 10 20 21 33 56] 10
=== RUN   TestBubbleSort3
--- PASS: TestBubbleSort3 (0.00s)
    bubble_sort_test.go:18: [5 10 20 21 33 56] 4
PASS
ok      command-line-arguments  0.006s

在冒泡排序中，n-1比较将在第一次进行，第二次进行n-2次，第三次进行n-3次，等等。所以比较的总数将是

(n-1)+(n-2)+(n-3)+.....+3+2+1
Sum = n(n-1)/2
i.e O(n2)

因此，冒泡排序的复杂度为O（n 2）。
冒泡排序的主要优点是算法的简单性。冒泡排序的空间复杂度为O（1），因为只需要单个额外的内存空间交互数字。
最佳时间复杂度将为O（n）。
算法的复杂性分析
最坏情况时间复杂度： O（n ^ 2）最佳情况时间复杂度： O（n）平均时间复杂度： O（n ^ 2）空间复杂度： O（1）