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

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

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

/**
* 冒泡排序
**/
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. 算法代码：

/**
* 快速排序
**/
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. 稳定性：不稳定