排序算法系列：快速排序

思想

快速排序采用的是分治法，其平均时间复杂度为O（nlogn）
一趟快速排序的算法是[1]：
　　1）设置两个变量I、J，排序开始的时候：I=0，J=N-1；
　　2）以第一个数组元素作为关键数据，赋值给key，即 key=A[0]；
　　3）从J开始向前搜索，即由后开始向前搜索（J=J-1即J–），找到第一个小于key的值A[j]，A[j]与A[i]交换；
　　4）从I开始向后搜索，即由前开始向后搜索（I=I+1即I++），找到第一个大于key的A[i]，A[i]与A[j]交换；
　　5）重复第3、4、5步，直到 I=J； (3,4步是在程序中没找到时候j=j-1，i=i+1，直至找到为止。找到并交换的时候i， j指针位置不变。另外当i=j这过程一定正好是i+或j-完成的最后另循环结束。）

数组快速排序代码

#include <iostream>

using namespace std;

int a[] = {100,8,15 ,37,26,13,27,49,55,14};

void quick_sort(int a[], int left, int right)
{
    if(left<right)
    {
    int i = left;
    int j = right;
    int x = a[i];

    while(i<j)
    {
        while(a[i] < x) i++;
        while(a[j] > x) j--;
        swap(a[i], a[j]);   
    }
    a[i] = x;
    quick_sort(a, left, i-1);
    quick_sort(a, i+1, right);
    }
}
int main()
{
    cout<<"Before sort: ";
    for(int i =0 ; i<10;i++)
        cout<<a[i]<<" ";
    cout<<endl;
    quick_sort(a, 0, 9);
    cout<<"After sort: ";
    for(int i =0 ; i<10;i++)
        cout<<a[i]<<" ";
    cout<<endl;
}

单链表快速排序代码

struct Node 
{
    int key;
    Node* next;
    Node(int nKey, Node* pNext)
        : key(nKey)
        , next(pNext)
    {}
};


Node* GetPartion(Node* pBegin, Node* pEnd)
{
    int key = pBegin->key;
    Node* p = pBegin;
    Node* q = p->next;

    while(q != pEnd)
    {
        if(q->key < key)
        {
            p = p->next;
            swap(p->key,q->key);
        }

        q = q->next;
    }
    swap(p->key,pBegin->key);
    return p;
}

void QuickSort(Node* pBeign, Node* pEnd)
{
    if(pBeign != pEnd)
    {
        Node* partion = GetPartion(pBeign,pEnd);
        QuickSort(pBeign,partion);
        QuickSort(partion->next,pEnd);
    }
}