golang ----------- 冒泡排序及其优化

1、普通方法：

func BubbleSort(a []int){
	for j := 0 ;j<len(a)-1; j++ {
		for i := 0; i<len(a)-j-1; i++ {
			if a[i] > a[i+1] {
				a[i],a[i+1] = a[i+1],a[i]
			}
		}
	}
	fmt.Println(a)
}

2、优化1：里面一层循环在某次扫描中没有执行交换，则说明此时数组已经全部有序列，无需再扫描了。设置一个标记位来标记此次遍历是否发生了交换，如果没有发生交换说明已经完成排序；

func BubbleBetterSort(a []int){
	for j := 0 ;j<len(a)-1; j++ {
		flag := true
		for i := 0; i<len(a)-j-1; i++ {
			if a[i] > a[i+1] {
				a[i],a[i+1] = a[i+1],a[i]
				flag = false        //如果没有出现这步骤,说明没有需要交换的了
			}
		}
		if flag {
			break
		}
	}
	fmt.Println(a)
}

3、优化2：如果R[i:len-1]已是有序区间，需要扫描区间是R[0:i]，记上次扫描时最后 一次执行交换的位置为lastSwap，则lastSwap在0与i之间，则R[lastSwapPos:i]区间也是有序的，否则这个区间也会发生交换；所以下次扫描区间就可以由R[0:i] 缩减到[0:lastSwap]。

func BubbleBestSort(a []int){
	lastSwap := len(a)-1
	lastSwapTemp := len(a)-1
	for j := 0 ;j<len(a)-1; j++ {
		lastSwap=lastSwapTemp
		for i := 0; i<lastSwap; i++ {
			if a[i] > a[i+1] {
				a[i],a[i+1] = a[i+1],a[i]
				lastSwapTemp = i
			}
		}
		if lastSwap == lastSwapTemp{
			break
		}
	}
	fmt.Println(a)
}

测试：

func main(){
	a := []int{4,6,5,2,9,11,34,21,22}
	base_sort.BubbleSort(a)
	base_sort.BubbleBetterSort(a)
	base_sort.BubbleBestSort(a)

/*	[2 4 5 6 9 11 21 22 34]
    [2 4 5 6 9 11 21 22 34]
    [2 4 5 6 9 11 21 22 34]*/
}

时间复杂度

若文件的初始状态是正序的，一趟扫描即可完成排序。所需的关键字比较次数 和记录移动次数  均达到最小值：

  ，  。所以，冒泡排序最好的时间复杂度为  。
若初始文件是反序的，需要进行  趟排序。每趟排序要进行  次关键字的比较(1≤i≤n-1)，且每次比较都必须移动记录三次来达到交换记录位置。在这种情况下，比较和移动次数均达到最大值：

冒泡排序的最坏时间复杂度为  。

综上，因此冒泡排序总的平均时间复杂度为  。

算法稳定性

冒泡排序就是把小的元素往前调或者把大的元素往后调。比较是相邻的两个元素比较，交换也发生在这两个元素之间。所以，如果两个元素相等，我想你是不会再无聊地把他们俩交换一下的；如果两个相等的元素没有相邻，那么即使通过前面的两两交换把两个相邻起来，这时候也不会交换，所以相同元素的前后顺序并没有改变，所以冒泡排序是一种稳定排序算法。