QuickSort

以56为基准，left向右移right向左移，若小于56，则覆盖0下标的56，然后left+1，right-1；若大于56，left+1，right-1。

int Partition(int* ar,int left,int right)//划分函数
{
    assert(ar!=nullptr);
    int tmp=ar[left];
    while(left<right)
    {
        while(left<right&&ar[right]>tmp)
        {
            --right;
        }
        if(left<right) ar[left]=ar[right];
        while(left<right&&ar[left]<=tmp)
        {
			++left;
        }
        if(left<right) ar[right]=ar[left];
    }
    ar[left]=tmp;
    return left;
}

void QuickPass(int* ar,int left,int right)//递归划分
{
    if(left<right)
    {
        int pos=Partition(ar,left,right);
        QuickPass(ar,left,pos-1);
        QuickPass(ar,pos+1,right);
    }
}
void QuickSort(int *ar,int n)
{
    assert(ar!=nullptr);
    QuickPass(ar,0,n-1);
}

如果数组近似有序，快排排序速度降低

快排原本的复杂程度为：(O)n=nlog2 n;

冒泡排序的复杂程度为：(O)n=n*n;

快排最后的复杂程度近似于冒泡排序

非递归划分

#include<queue>
using namepace std;
void NiceQuickSort(int *ar,int n)//非递归排序
{
    assert(ar!=nullptr);
    int left=0,right=n-1;
    queue<int >qu;
    qu.push(left);
    qu.push(right);
    while(!qu.empty())
    {
        left=qu.front();qu.pop();
        right=qu.front();qu.pop();
        int pos=Partition(ar,left,right);
        if(left<pos-1)
        {
            qu.push(left);
            qu.push(pos-1);
        }
        if(pos+1<right)
        {
            qu.push(pos+1);
            qu.push(right);
        }
    }
}

随机划分法：

template<class Type>
void Swap(Type& a,Type& b)
{
    int tmp=a;
    a=b;
    b=tmp;
}
int RandPartition(int* ar,int left,int right)
{
    int index=rand()%(right-left)+left;//+left保证后半部分的下标不错乱
    Swap(ar[left],ar[right]);
    return Partition(ar,left,right);
}

快排程序：

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<queue>
using namepace std;
template<class Type>
void Swap(Type& a,Type& b)
{
    int tmp=a;
    a=b;
    b=tmp;
}
int Partition(int* ar,int left,int right)//划分函数
{
    assert(ar!=nullptr);
    int tmp=ar[left];
    while(left<right)
    {
        while(left<right&&ar[right]>tmp)
        {
            --right;
        }
        if(left<right) ar[left]=ar[right];
        while(left<right&&ar[left]<=tmp)
        {
			++left;
        }
        if(left<right) ar[right]=ar[left];
    }
    ar[left]=tmp;
    return left;
}
int RandPartition(int* ar,int left,int right)//随机划分
{
    int index=rand()%(right-left)+left;//+left保证后半部分的下标不错乱
    Swap(ar[left],ar[right]);
    return Partition(ar,left,right);
}
void QuickPass(int* ar,int left,int right)//递归排序
{
    if(left<right)
    {
        int pos=RandPartition(ar,left,right);
        QuickPass(ar,left,pos-1);
        QuickPass(ar,pos+1,right);
    }
}

void QuickSort(int *ar,int n)
{
    assert(ar!=nullptr);
    QuickPass(ar,0,n-1);
}

void NiceQuickSort(int *ar,int n)//非递归排序
{
    assert(ar!=nullptr);
    int left=0,right=n-1;
    queue<int >qu;
    qu.push(left);
    qu.push(right);
    while(!qu.empty())
    {
        left=qu.front();qu.pop();
        right=qu.front();qu.pop();
        int pos=Partition(ar,left,right);
        if(left<pos-1)
        {
            qu.push(left);
            qu.push(pos-1);
        }
        if(pos+1<right)
        {
            qu.push(pos+1);
            qu.push(right);
        }
    }
}

int main()
{
    int ar[]={56,23,78,45,90,100,12,34,67,89};
    int n=sizeof(ar)/sizeof(ar[0]);
    QuickSort(ar,n);
    NiceQuickSort(ar,n);
    return 0;
}