双向冒泡排序 冒泡排序 性能对比
数据结构与算法与语言无关，此篇博文用的描述语言是go
冒泡排序
冒泡排序的时间复杂度是O(n2)
先看一个简单的冒泡排序
//普通冒泡排序
func normalBubbleSort(sequence []int){
for i := 0;i < len(sequence) - 1;i++ {
for j := 0;j < len(sequence) - 1 - i;j++ {
if sequence[j] > sequence[j + 1] {
//交换元素值
sequence[j], sequence[j + 1] = sequence[j + 1], sequence[j]
}
}
}
}这是一个相当简单的冒泡排序
冒泡排序就如它的名字一样，冒泡，在上述算法中，第一趟排序会确定最大的一个值，并把它放在尾部，第二趟会确定一个第二大的值，放在倒数第二位……，直到没有元素可交换为止（本文着重讨论性能对比，要是想了解冒泡排序，可以看看相关的文章，这里就不再赘述了）
比如一个序列为{5,2,73,7,3,9,2,8}
第一趟冒泡排序后它会是下面这样
经过多次排序之后，整个序列变成有序的
双向冒泡排序
接下来看一下改进后的冒泡排序，双向冒泡排序。原始的冒泡排序是是单向的，它始终是从下标为0的元素向后扫描
而双向冒泡排序是从两端进行扫描
首先从首部到尾部进行扫描，把最大的数往后交换，然后从尾部到首部进行扫描，把最小的数往前交换，多次扫描后，最终得到一个有序的序列
代码实现
//双向冒泡排序
func bubbleSort(sequence []int){
var i int
//是否交换标志
isSwap := true
for isSwap {
isSwap = false
//自顶而下的扫描
for j := i;j < len(sequence) - i - 1;j++ {
if sequence[j] > sequence[j + 1] {
sequence[j], sequence[j + 1] = sequence[j + 1], sequence[j]
isSwap = true
}
}
//自底而下的扫描
for j := len(sequence) - i - 1;j >= i + 1;j-- {
if sequence[j] < sequence[j - 1] {
sequence[j], sequence[j - 1] = sequence[j - 1], sequence[j]
}
isSwap = true
}
i++
}
}改进后的双向冒泡排序
双向冒泡排序固然很好，但是上述的代码有个问题，做了一些无用的工作，比如，双向扫描每次都把已经有序的部分再扫描了一遍。
例如，经过两次扫描后的结果：
由此可见，该序列两边的两个元素都已经有序了，而下次扫描还会扫描到两边的两个元素
改进方法是创建两个哨兵，sentryI之前的部分是已经有序的部分，sentryJ之后的部分也是有序的部分，那么每次扫描，只需要扫描，sentryI到sentryJ中间的部分就行了
那么这样第三次扫描就只需要扫描蓝色的部分即可，在每次扫描过后sentryI++，sentryJ—，直到sentryI >= sentryJ的时候停止扫描，此时序列中的元素已经有序
代码实现
//冒泡排序2
func bubbleSort2(sequence []int){
//i ,j 哨兵
var sentryI ,sentryJ int = 0, len(sequence) - 1
for sentryI < sentryJ {
//自顶而下的扫描
for i := sentryI;i < sentryJ;i++ {
if sequence[i] > sequence[i + 1] {
sequence[i], sequence[i + 1] = sequence[i + 1], sequence[i]
}
}
sentryJ--
//自底而上的扫描
for i := sentryJ;i > sentryI;i-- {
if sequence[i] < sequence[i - 1] {
sequence[i], sequence[i - 1] = sequence[i - 1], sequence[i]
}
}
sentryI++
}
}性能对比
现在来对比一下三个排序算法（普通冒泡，双向冒泡，改进后的双向冒泡）的性能
首先初始化随机产生10k个数，放入一个容器中，然后对这个10k个数进行排序，看一下所消耗的时间
以下给出代码实现
package main
import (
"time"
"fmt"
"math/rand"
)
var sequence []int = make([]int,10000)
//初始化序列
func init(){
for i := 0;i < 10000;i++ {
sequence[i] = rand.Intn(10000)
}
}
func main(){
//普通冒泡排序
t := time.Now()
normalBubbleSort(sequence)
fmt.Println(time.Since(t))
//双向冒泡排序
t = time.Now()
bubbleSort(sequence)
fmt.Println(time.Since(t))
//改进版冒泡排序
t = time.Now()
bubbleSort2(sequence)
fmt.Println(time.Since(t))
}
//普通冒泡排序
func normalBubbleSort(sequence []int){
for i := 0;i < len(sequence) - 1;i++ {
for j := 0;j < len(sequence) - 1 - i;j++ {
if sequence[j] > sequence[j + 1] {
sequence[j], sequence[j + 1] = sequence[j + 1], sequence[j]
}
}
}
}
//双向冒泡排序
func bubbleSort(sequence []int){
var i int
//是否交换标志
isSwap := true
for isSwap {
isSwap = false
//自顶而下的扫描
for j := i;j < len(sequence) - i - 1;j++ {
if sequence[j] > sequence[j + 1] {
sequence[j], sequence[j + 1] = sequence[j + 1], sequence[j]
isSwap = true
}
}
//自底而下的扫描
for j := len(sequence) - i - 1;j >= i + 1;j-- {
if sequence[j] < sequence[j - 1] {
sequence[j], sequence[j - 1] = sequence[j - 1], sequence[j]
}
isSwap = true
}
i++
}
}
//改进版冒泡排序
func bubbleSort2(sequence []int){
//i ,j 哨兵
var sentryI ,sentryJ int = 0, len(sequence) - 1
for sentryI < sentryJ {
//自顶而下的扫描
for i := sentryI;i < sentryJ;i++ {
if sequence[i] > sequence[i + 1] {
sequence[i], sequence[i + 1] = sequence[i + 1], sequence[i]
}
}
sentryJ--
//自底而上的扫描
for i := sentryJ;i > sentryI;i-- {
if sequence[i] < sequence[i - 1] {
sequence[i], sequence[i - 1] = sequence[i - 1], sequence[i]
}
}
sentryI++
}
}打印结果
120.6209ms //普通版冒泡排序
59.073403ms //双向冒泡排序
40.989477ms //改进版冒泡排序可以看到普通版冒泡排序比其它两个的两倍还要多！
我们再加大排序的量，改成初始化100k个数，来排序这100k个数
普通版冒泡排序等的我差点放弃，来看一下打印结果
打印结果
16.369802704s //普通版冒泡排序
5.811546606s //双向冒泡排序
3.753537398s //改进版冒泡排序普通版冒泡排序用了整整16s！！！而双向冒泡只用了5s，改进版的仅仅只用了3s
通过数据量的增加可以明显的看出差距了
虽然平时我们不大可能会遇到这么大的数据量，而小数据量的差距又不是很大，再说了，如果你做顶层开发，许多语言都封装了排序算法，直接调用就行了，不必这么大费周章，但是，我觉得了解算法及其性能是很有必要的，它始终能渗透你的思维