Golang实现快速排序

定义

快速排序（英语：Quicksort），又称划分交换排序（partition-exchange sort），简称快排，一种排序算法，最早由东尼·霍尔提出。在平均状况下，排序 n个项目要 O(n\log n)（大O符号）次比较。在最坏状况下则需要 O(n^{2})} {O(n^{2})次比较，但这种状况并不常见。事实上，快速排序 Theta (n\log n)通常明显比其他算法更快，因为它的内部循环（inner loop）可以在大部分的架构上很有效率地达成。

算法

快速排序使用分治法（Divide and conquer）策略来把一个序列（list）分为两个子序列（sub-lists）。
步骤为：
从数列中挑出一个元素，称为“基准”（pivot），
重新排序数列，所有比基准值小的元素摆放在基准前面，所有比基准值大的元素摆在基准后面（相同的数可以到任何一边）。在这个分割结束之后，该基准就处于数列的中间位置。这个称为分割（partition）操作。
递归地（recursively）把小于基准值元素的子数列和大于基准值元素的子数列排序。
递归到最底部时，数列的大小是零或一，也就是已经排序好了。这个算法一定会结束，因为在每次的迭代（iteration）中，它至少会把一个元素摆到它最后的位置去。

原地排序版本
本例采用原地排序版本。
简单版本的缺点是，它需要 Omega (n)的额外存储空间，也就跟归并排序一样不好。额外需要的存储器空间配置，在实际上的实现，也会极度影响速度和缓存的性能。有一个比较复杂使用原地（in-place）分割算法的版本，且在好的基准选择上，平均可以达到 O(\log n)空间的使用复杂度。

实现

// quickSort project main.go
package main

import (
	"fmt"
)

func quickSort(c []int, left, right int) []int {
	var n = len(c)
	if n <= 1 {
		return c
	}
	if right-left < 2 {
		return c
	}
	var de = sort(c, left, right-1)
	quickSort(c, left, de)
	quickSort(c, de+1, right)
	return c

}
func sort(c []int, s, p int) int {
	var pivot = c[p]
	var r = p - 1
	var l = s
	for i := s; i < p; i++ {
		if c[i] >= pivot {
			l = i
			for j := r; j > s-1; j-- {
				if l == j {
					c[i], c[p] = c[p], c[i]
					return l
				}
				if c[j] <= pivot {
					r = j
					c[i], c[j] = c[j], c[i]
					break
				}
			}
		}
	}
	for j := r; j > s-1; j-- {
		if c[j] <= pivot {
			c[l], c[j] = c[j], c[l]
			return j
		}
	}
	return p
}

测试

//test
func main() {
	var b = []int{9, 8, 6, 7, 4, 5, 3, 2, 1}
	var m = len(b)
	fmt.Println(quickSort(b, 0, m))
}