排序(五)-快速排序

稳定性:unstable sort

空间:In-place sort

最优复杂度:O(nlgn)

最差复杂度:O(n^2)

伪代码:

Quick_sort(A)
{
    recursive_quicksort(A,1,length[A])
}

recursive_quicksort(A,p,q)
{
    if p<q
        r = partition(A,p,q)
        recursive_quicksort(A,p,r-1)
        recursive_quicksort(A,r+1,q)
}

partition(A,p,q)
{
    i = p-1
    pivot = A[q]
    for j=p to q-1
        if A[j] <= pivot
            i++
            swap A[i] <-> A[j]
    swap A[i+1] <-> A[q]
    return i+1
}

Java代码:

import java.util.Arrays;

public class Main {
	public static void main(String[] args){
		Main m = new Main();
		int[] A = {1,2,3,5,4,7,9,1,2,5,3,2,1};
		m.quickSort(A);
		System.out.print(Arrays.toString(A));
		//输出:[1, 1, 1, 2, 2, 2, 3, 3, 4, 5, 5, 7, 9]
	}
	
	public void quickSort(int[] A){
		recursiveQuickSort(A,0,A.length-1);
	}
	
	public void recursiveQuickSort(int[] A,int p,int q){
		if(p < q){
			int r = partition(A,p,q);
			recursiveQuickSort(A,p,r-1);
			recursiveQuickSort(A,r+1,q);
		}
	}
	
	public int partition(int[] A,int p,int q){
		int i = p - 1;
		int pivot = A[q];
		for(int j = p; j < q; ++j){
			if(A[j] <= pivot){
				++i;
				swap(A,i,j);
			}
		}
		swap(A,i+1,q);
		return i+1;
	}
	
	public void swap(int[] A,int x,int y){
		int temp = A[x];
		A[x] = A[y];
		A[y] = temp;
	}
}