经典排序算法

冒泡排序

冒泡排序的基本思想是，对相邻的元素进行两两比较，顺序相反则进行交换，这样，每一趟会将最小或最大的元素“浮”到顶端，最终达到完全有序。

特点：如果N个元素按照从小到大排序，每一轮(i)排序后，最大的元素会放到最后，后续新一轮只需要前N-i个元素互相比较。

题目：给出无需数组 [4,3,1,2]，要求按照从小到大使用冒泡排序法排序。
输出样例：

1
2
3
4

package main 
import "fmt"


//冒泡排序
//时间O(N^2),最好O(N);空间O(1)
//相邻记录两两比较，如果反序则交换
func BubbleSort(arr []int) {
	l := len(arr)
	flag := true //正宗的冒泡可以优化的
	for i := 0; i < l && flag; i++ {
		flag = false
		for j := l - 2; j >= i; j-- { 
			if arr[j] > arr[j+1] { 
				arr[j], arr[j+1] = arr[j+1], arr[j]
				flag = true
			}
		}
	}
}

func main(){
	arr := []int{1,5,2,49,3,1}
	BubbleSort(arr)
	fmt.Println(arr)
}

测试：

$ go run main.go

[1 1 2 3 5 49]

快速排序

之所以和冒泡排序列在一起，因为快速排序是冒泡排序的升级，属于交换排序类型。

package main 
import "fmt"

//快速排序
//时间复杂度N*O(logN)，空间复杂度O(logN)。空间复杂度是递归造成的。不稳定排序。
func QuickSort(arr []int){
	qucikSortH(arr, 0, len(arr) - 1)
}

func qucikSortH(arr []int, low int, high int){
	if low < high {
		//partition
		pivotKey := partition(arr, low, high)

		qucikSortH(arr, low, pivotKey-1)
		qucikSortH(arr, pivotKey+1, high)
	}
}

func partition(arr []int, low int, high int) int{
	pivot := arr[low]
	for low < high {
		for low < high && arr[high] >= pivot {
			high--
		}
		arr[low], arr[high] = arr[high], arr[low]

		for low < high && arr[low] <= pivot {
			low++
		}
		arr[low], arr[high] = arr[high], arr[low]
	}

	return low
}

func main(){
	arr := []int{1,5,2,49,3,1}
	QuickSort(arr)
	fmt.Println(arr)
}

测试：

$ go run main.go

[1 1 2 3 5 49]

参考：
图解排序算法(一)之3种简单排序(选择，冒泡，直接插入) - dreamcatcher-cx - 博客园
http://www.cnblogs.com/chengxiao/p/6103002.html