快速排序（不稳定）

快速排序（不稳定）：快速排序是从冒泡元素演变而来。在快速排序中，元素的比较和交换是从两端向中间进行的，较大的元素一轮就能交换到后面的位置，而较小的
元素一轮就能交换到前面的位置，元素每次移动的距离较远，所以比较次数和移动次数较少，速度较快。
1.在待排序的元素任取一个元素作为基准（通常选第一个元素，但最好的方法是从待排序元素中随机选取一个为基准），称为基准元素（pivot）
2.将待排序的元素进行分区，比基准元素大的元素放在它的右边，比基准元素小的放在它的左边
3.对左右两个分区重复以上步骤，直到所有的元素都是有序的

时间复杂度：平均o(nlogn)、最坏o(n^2)
空间复杂度：平均o(logn)、最坏o(n)

java

public static void quickSort(int[] arr, int left, int right){
        if(left >= right) return;
        int l = left;
        int r = right;
        int flag = arr[left];//基准元素
        while(l < r){
            while(arr[r] >= flag && l < r){//从右往左找比基准元素小的第一个元素
                r--;
            }
            if(l < r){
                int temp = arr[l];
                arr[l] = arr[r];
                arr[r] = temp;
            }
            while(arr[l] <= flag && l < r){//从左往右找比基准元素大的第一个元素
                l++;
            }
            if(l < r){
                int temp = arr[l];
                arr[l] = arr[r];
                arr[r] = temp;
            }
        }
        quickSort(arr, left, l);//排序数组左半部分
        quickSort(arr,l+1, right);//排序数组右半部分
    }

go

func quickSort(array []int, start, end int) {
	if start > end {
		return
	}
	index := partition(array, start, end)
	quickSort(array, start, index -1)
	quickSort(array, index + 1, end)
}

func partition(array []int, start, end int) int{
	left, right := start, end
	pivot := array[start]
	index := left
	for left <= right {
		for left <= right {
			if array[right] < pivot {
				array[left] = array[right]
				index = right
				left++
				break
			}
			right--
		}
		for left <= right {
			if array[left] > pivot {
				array[right] = array[left]
				index = left
				right--
				break
			}
			left++
		}
	}
	array[index] = pivot
	return index
}