Quicksort的算法分析及C++实现

一、关于Quicksort的简单介绍

Quicksort算法属于divide and conquer算法，核心思想是取array中的一个元素作为pivot，然后把array除了pivot的其他元素与这个pivot进行比较，比pivot小的元素放在pivot左边，比pivot大的元素放在pivot的右边，我们就得到了两个subarray（左边和右边），然后再对新的subarray进行同样的操作，直到得到新array中只有一个元素。

二、quicksort的C++程序实现：

//
//  main.cpp
//  quicksort
//
//  Created by lingnan on 10/21/15.
//  Copyright (c) 2015 lingnan. All rights reserved.
//

#include <iostream>
using namespace std;

int partition(int arr[], int left, int right){
    int pivot = arr[right];                 //choose the rightest element as the pivot
    int curr = left;
    for(int i=left; i<right; i++){
        if(pivot > arr[i]){                 //always put smaller element in the left
            swap(arr[curr], arr[i]);
            curr++;
        }
    }
    swap(arr[curr], arr[right]);           //at last, put pivot element in the position it should be
    return curr;
}

void quicksort(int arr[], int left, int right){
    if(left < right){
        int p = partition(arr, left, right);
        quicksort(arr, left, p-1);
        quicksort(arr, p+1, right);
    }
}

void printArray(int arr[], int n){
      cout <<"The final result after quicksort is:" <<endl;
    for(int i=0; i<n; i++){
      cout <<arr[i] <<" ";
    }
}

int main(int argc, const char * argv[]) {
    int arr[] = {1,56,2,2,35,3,3,93};
    int n = sizeof(arr)/sizeof(arr[0]);      //get the number of elements in array
    quicksort(arr, 0, n-1);
    printArray(arr, n);
    return 0;
}

三、时间复杂度和空间复杂度

T(n) = T(k) + T(n-k-1) + O(n)

T(n)是一次quicksort的时间复杂度，O(n)是partition一次的时间(每次paritition都要遍历所有的元素），T(k) 和 T(n-k-1)是分别要继续遍历的两个新数组。

Worst Case:

T(n) = T(1) + T(n-2) + O(n)  ~ O(n^2)

每次只分出一个元素

Best Case:

T(n) = 2*T(n/2) + O(n)  ~ O(nlogn)

每次分出的两堆数量相似

Average Case:

O(nlogn)

空间复杂度：in place