交换排序（冒泡排序、快速排序）

交换排序的基本方法：
两两比较待排序对象的排序码，如果发生逆序，则交换之，直到所有对象都排好序为止。
交换排序的实施方案：
1. 冒泡排序
2. 快速排序

 

一、冒泡排序
1. 算法代码：

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

/** * 冒泡排序 **/ func BubbleSort(data []int) {     for i := 0; i < len(data)-1; i++ { //一共冒泡len(data)-1趟         exchange := false         for j := 0; j < len(data)-i-1; j++ {             if data[j] > data[j+1] {                 data[j], data[j+1] = data[j+1], data[j]                 exchange = true             }         }         if !exchange { //没有发生移位，说明已排序完成，提前退出冒泡             break         }     } }

2. 空间复杂度：O(1)
3. 时间复杂度：O(n*n)
4. 稳定性：稳定

 

二、快速排序
1. 算法描述：
任取待排序对象中某个对象作为基准，按照该对象的排序码大小，将所有对象划分为左右两个子序列，左序列所有对象排序码都小于或等于基准对象的排序码，右序列所有对象的排序码都大于基准对象的排序码，基准对象则放置在这两个序列中间，然后分别对这两个子序列重复实施上述方法，直至所有对象都排在相应位置上为止。
2. 算法代码：

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

/** * 快速排序 **/ func QuickSort(slice []int, start, end int) {     if start >= end {         return     }     i, j := start, end     val := slice[(i+j)/2]     for i <= j {         for i <= end && slice[i] < val {             i++         }         for j >= start && slice[j] > val {             j--         }         if i <= j {             slice[i], slice[j] = slice[j], slice[i]             i++             j--         }     }       if start < j {         QuickSort(slice, start, j)     }     if end > i {         QuickSort(slice, i, end)     } }

2. 空间复杂度：O(log2n)
3. 时间复杂度：O(nlog2n)
就平均计算时间而言，快速排序时所有内排序方法中最好的一个。
4. 稳定性：不稳定