快速排序（从小到大）

思路：

1. 排序数组[90, 61, 60, 10, 20, 50]

2. 首先以数组长度二分之一为参照值 索引为2  参照值就是60，在左边找到，比参照值小的大的，此例90就是  索引为0
3. 接着在参照值右边找到比参照值小的值， 这里就是50 索引为 5
4. 交换两个所以的值 第一次循环排序后的结果为  [50, 61, 60, 10, 20, 90]
5.  进入下一次循环， 此时参照值还是 60  ，继续找到左边 61  ，右边找到20  ，交换结果为  [50, 20, 60, 10, 61, 90]
6. 继续循环  l 为 2  ， r 为3  交换  结果为[50, 20, 10, 60, 61, 90]， arr[r]  = 60 则把 l+1    此时l为3  r 为3  ，跳出循环， l = r  则把 l++ r--   则此时 l为4  r为2进入到 递归阶段了
7.  此时进入向左递归   left = 0  right = 2  arr为 [50, 20, 10, 60, 61, 90]
8.  参照值为20 ， 此时 左边递归内l = 1  r=2  交换得到 [10, 20, 50, 60, 61, 90]
9. 继续循环  l=1   r = 1  ，跳出循环   l=2  r = 0  这里向左递归已完成
10. 向右递归   left = 4   right = 5    arr为 [10, 20, 50, 60, 61, 90]， 循环完成 l=r 则也结束循环
11. 最终得到结果[10, 20, 50, 60, 61, 90]

注：内部的优化，是加快效率，因为，不优化会多一次循环

func QuickSort(left, right int, array *[arrSize]int) {
	l := left
	r := right
 
	pivot := array[(left+right)/2]
	//for循环的目标是将比pivot小的数放在左边，比pivot大的数放在右边
	for l < r {
		//从pivot左边找到一个大于等于pivot的值
		//重新排序后，会把排序过后的重新检查一遍
		for array[l] < pivot {
			l++
		}
		//从pivot右边找到小于等于pivot的值
		for array[r] > pivot {
			r--
		}
		//表明本次分解任务完成
		if l >= r {
			break
		}
		//交换
		array[l], array[r] = array[r], array[l]
		fmt.Println(array)
		//优化：这里是条件符合，说明另外一边刚好就是pivot，则下一轮不需要做判断，可以直接跳过，节省一次循环
		if array[l] == pivot {
			r--
		}
		if array[r] == pivot {
			l++
		}
		//	fmt.Printf("%v\n", *array)
	}
	//可注释以下代码做测试
	//如果l==r，再移动下
    //这里注释会报错，会死循环造成栈溢出
	if l == r {
		l++
		r--
	}
	//向左递归
	if left < r {
		QuickSort(left, r, array)
	}
	//向右递归
	if right > l {
		QuickSort(l, right, array)
	}
}
 
 
func main() {
	arr := [arrSize]int{90, 61, 60, 10, 20, 50}
	//rand.Seed(time.Now().UnixNano())
	//for i := 0; i < arrSize; i++ {
	//	arr[i] = rand.Intn(arrSize)
	//}
 
	start := time.Now()
	QuickSort(0, len(arr)-1, &arr)
	elapse := time.Since(start)
	fmt.Println("消耗时间:", elapse, arr)
}