【排序算法】十大排序之快速排序

快速排序

快速排序是一种分治的排序算法。

快速排序的基本思想：通过一趟排序将待排序列分隔成独立的两部分，其中一部分记录的元素均比另一部分的元素小，则可分别对这两部分子序列继续进行排序，以达到整个序列有序。

算法步骤

快速排序使用分治法策略来把一个序列分为较小和较大的 2 个子序列，然后递回地排序两个子序列。具体算法描述如下：

1. 从序列中随机挑出一个元素，做为 “基准”(pivot)；
2. 重新排列序列，将所有比基准值小的元素摆放在基准前面，所有比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个操作结束之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
3. 递归地把小于基准值元素的子序列和大于基准值元素的子序列进行快速排序。

基本实现

Golang版

func partition(data []int, low, high int) int {
	pivot := data[high]
	pointer := low

	for i := low; i < high; i++ {
		if data[i] <= pivot {
			data[i], data[pointer] = data[pointer], data[i]
			pointer++
		}
	}

	data[high], data[pointer] = data[pointer], data[high]
	return pointer
}

func quickSort(data []int, low, high int) {
	if low < high {
		position := partition(data, low, high)
		quickSort(data, low, position-1)
		quickSort(data, position+1, high)
	}
}

优化一

• 随机取得pivot，这是针对渐进有序的数组的情况，普通快速排序效率过低的问题，也就是上面提到的平衡树的两端。避免因为数组本身的特点总是取到最值的情况。

func randomPivot(data []int, low, high int) int {
	i := rand.Intn(high-low+1) + low
	data[i], data[high] = data[high], data[i]
	return partition(data, low, high)
}

func partition(data []int, low, high int) int {
	pivot := data[high]
	pointer := low

	for i := low; i < high; i++ {
		if data[i] <= pivot {
			data[i], data[pointer] = data[pointer], data[i]
			pointer++
		}
	}

	data[high], data[pointer] = data[pointer], data[high]
	return pointer
}

func quickSort(data []int, low, high int) {
	if low < high {
		position := randomPivot(data, low, high)
		quickSort(data, low, position-1)
		quickSort(data, position+1, high)
	}
}

优化二

• 三路快排（三指针法），把等于pivot元素的所有元素放在分割区间的中间，也就是说我们每次递归确定的是这个元素以及和它相等的元素的位置，大量元素相等的情况下，递归区间大大减少。

//TODO

Rust版

pub fn main() {
    let mut data = [1, 4, 5, 7, 4, 6, 3];
    let high = data.len()-1;
    quick_sort(&mut data, 0, high);
    println!("{:?}", data);
}

fn quick_sort(data: &mut [i32], low: usize, high: usize) {
    if low < high {
        let position = partition(data, low, high);
        quick_sort(data, low, position-1);
        quick_sort(data, position+1, high);
    }
}

fn partition(data: &mut [i32], low: usize, high: usize)-> usize {
    let pivot= data[high];

    let mut pointer = low;

    for i in low..high {
        if data[i] <= pivot {
            data.swap(i, pointer);
            pointer+=1;
        }
    }
    data.swap(pointer, high);
    return pointer;
}

优化一

use rand::Rng;

pub fn main() {
    let mut data = [1, 4, 5, 7, 4, 6, 3];
    let high = data.len() - 1;
    quick_sort(&mut data, 0, high);
    println!("{:?}", data);
}

fn quick_sort(data: &mut [i32], low: usize, high: usize) {
    if low < high {
        let position = rand_pivot(data, low, high);
        quick_sort(data, low, position - 1);
        quick_sort(data, position + 1, high);
    }
}

fn partition(data: &mut [i32], low: usize, high: usize) -> usize {
    let pivot = data[high];

    let mut pointer = low;

    for i in low..high {
        if data[i] <= pivot {
            data.swap(i, pointer);
            pointer += 1;
        }
    }
    data.swap(pointer, high);
    return pointer;
}

fn rand_pivot(data: &mut [i32], low: usize, high: usize) -> usize {
    let mut random = rand::thread_rng();
    let i = random.gen_range(0, high - low + 1) + low;
    data.swap(i, high);
    return partition(data, low, high);
}

Java版

private static void quickSort(int[] data, int low, int high) {
    if (low < high) {
        int position = partition(data, low, high);
        quickSort(data, low, position-1);
        quickSort(data, position+1, high);
    }
}

private static int partition(int[] data, int low, int high){
    int pivot = data[high];

    int pointer = low;

    for (int i=low; i < high; i++){
        if (data[i] <= pivot){
            int tmp = data[i];
            data[i] = data[pointer];
            data[pointer] = tmp;
            pointer++;
        }
    }
    int tmp = data[pointer];
    data[pointer] = data[high];
    data[high] = tmp;
    return pointer;
}

优化一

private static void quickSort(int[] data, int low, int high) {
    if (low < high) {
        int position = randPivot(data, low, high);
        quickSort(data, low, position - 1);
        quickSort(data, position + 1, high);
    }
}

private static int partition(int[] data, int low, int high) {
    int pivot = data[high];

    int pointer = low;

    for (int i = low; i < high; i++) {
        if (data[i] <= pivot) {
            int tmp = data[i];
            data[i] = data[pointer];
            data[pointer] = tmp;
            pointer++;
        }
    }
    int tmp = data[pointer];
    data[pointer] = data[high];
    data[high] = tmp;
    return pointer;
}

private static int randPivot(int[] data, int low, int high) {
    Random random = new Random();
    int i = random.nextInt(high - low + 1) + low;
    int tmp = data[i];
    data[i] = data[high];
    data[high] = tmp;
    return partition(data, low, high);
}

算法分析

稳定性：不稳定

时间复杂度：最佳：O(nlogn)， 最差：O(nlogn)，平均：O(nlogn)

空间复杂度：O(nlogn)