快速排序（quickSort）

快速排序
算法思路：
1.选择一个基准值pivot,
2.利用partiton函数将数组划分为 [小于pivot, pivot, 大于pivot]的结构
2.分治递归arr左半部分与arr右半部分
平均时间复杂度：O(nlogn)
最佳时间复杂度：O(nlogn)
最差时间复杂度：O(n2)
空间复杂度：O(1)
稳定性：不稳定，由于pivot的选择不同，
在选择基准值的时候，越靠近中间，性能越好；越靠近两边，性能越差。
适合场景：待排序序列元素较多，并且元素较无序。
代码实现：

package main

import (
	"fmt"
	"math/rand"
)

func main() {
	arr := []int{1, 7, 6, 5, 4, 9}
	quickSort(arr, 0, len(arr)-1)
	for _, v := range arr {
		fmt.Println(v)
	}
}

func quickSort(arr []int, left, right int) {
	if left >= right {
		return
	}
	// 随机选择pivot
	pivot := rand.Intn(right-left) + left
	arr[pivot], arr[right] = arr[right], arr[pivot]
	index := partition(arr, left, right)
	// 分治递归左半部分 arr[left : index[0] - 1]
	quickSort(arr, left, index[0]-1)
	// 分治递归右半部分 arr[index[1] + 1 : right]
	quickSort(arr, index[1]+1, right)
}

// partition函数：找到与arr[j]相等的区间(arr[j]作为pivot)
// 返回等于pivot的左边界索引与右边界索引
func partition(arr []int, i, j int) []int {
	// L: 记录小于pivot的右边界索引
	// R: 记录大于pivot的左边界索引
	L, R := i-1, j
	for i < R {
		// 如果arr[i] < arr[j]: L右移，交换arr[L]与arr[i],i递增
		if arr[i] < arr[j] {
			L++
			arr[L], arr[i] = arr[i], arr[L]
			i++
			// 如果arr[i] > arr[j]: R左移，交换arr[R]与arr[i]
		} else if arr[i] > arr[j] {
			R--
			arr[R], arr[i] = arr[i], arr[R]
			// 如果arr[i] == arr[j]: i递增
		} else {
			i++
		}
	}
	// 将arr[j]放到中间部分
	arr[R], arr[j] = arr[j], arr[R]
	return []int{L + 1, R}
}