快速排序

一、快速排序

核心思想：采用分治策略(divide and conquer)。

基线条件是数组为空或者只包含一个数组，这种情况下，只需要原样返回数组，不用排序。

　　　if(len(array)<2)return array;

　　　quicksort(array);

快排核心代码：

void quicksort(int array[],int left,int right)
{
    int i,j,temp;
    if(left<right)
    {
        i=left;
        j=right;
        temp=array[i];
        while(i<j)
        {
            while(i<j&&array[j]>temp)j--;
            if(i<j)array[i++]=array[j];
            while(i<j&&array[i]<temp)i++;
            if(i<j)array[j--]=array[i];
        }
        array[i]=temp;
        quicksort(array,left,i-1);//递归调用
        quicksort(array,i+1,right);
    }
}
//快速排序，QuickSort(array,left,right);
if(left<right)
{
    flag=partition(array,left,right);//分成两部分，一部分小于等于temp=array[0],一部分大于等于temp=array[0]
    quicksort(array,left,flag-1);//递归左边
    quicksort(array,flag+1,right);//递归右边
}
Partition(array,left,right)
x=array[left]//选择第一个元素作为基准
i=left-1
int partition(int array[],int left,int right)
{
    int temp=array[left]
    int i=left-1;j=left;
    for(j=left;j<right-1;j++)
    {
        if(array[j]<=temp)
        {
            i++;
            if(i!=j)
            swap(array[i],array[j]);
        }
    }
    swap(array[i+1],array[right]);
    return (i+1);
}

具体实现：

/*
    快速排序算法
*/
#include<stdio.h>
#include<stdlib.h>
#define BUF_SIZE 100
//打印方法
void display(int array[],int maxlen)
{
    int i;
    for(int i=0;i<maxlen;i++)
    {
        printf("%3d",array[i]);
    }
    return;
}
//交换方法
void swap(int *a,int *b)
{
    int temp;
    temp=*a;
    *a=*b;
    *b=temp;
    return;
}
//排序方法
void quicksort(int array[],int maxlen,int begin,int end)
{
    int i,j;
    if(begin<end)
    {
        j=begin+1;//将array[begin]作为基准数，因此从array[begin+1]开始与基准数无回比较
        j=end;
        while(i<j)
        {
            if(array[i]>array[begin])//如果比较的数组元素大于基准数，则交换位置
            {
                swap(&array[i],&array[j]);//交换位置
                j--;
            }
            else
            {
                i++;//将数组向后移一位，继续与基准数比较
            }
            /*
                跳出while循环后i=j
                此时数组被分割成两个部分---->array[begin+1]~array[i-1]<array[begin]
                                    ----->array[i+1]~array[end]>array[begin]
                这个时候将数组array分成两个部分，再将array[i]与array[begin]进行比较
                决定array[i]的位置
                最后将array[i]与array[begin]交换，进行连个分割部分的排序，
                以此类推，知道最后i=j不满条件就跳出
            */
            if(array[i]>=array[begin])//这里必须要取等>=,否则数组元素相同的值，会出错
            {
                i--;
            }
            swap(&array[begin],&array[i]);//交换array[i]与array[begin]
            quicksort(array,maxlen,begin,i);
            quicksort(array,maxlen,j,end);
        }
    }


}

 算法性能分析：

平均情况

快速排序的平均运行时间为θ(nlogn)。在有序的情况下，快速排序是θ(n^2),当存在相同的元素的时候，快排在进行比较的时候可能会导致原来元素顺序发生变化。所以它是不稳定的。

 

 二、随机快速排序

1、划分函数的实现

int RandomizedPartition(T a[],int p,int r)
{
    int i=Random(p,r);
    swap(a[i],a[p]);
    return Partition(a,p,r);
}

2、随机快速排序算法的实现

void RandomizedQuickSort(T a[],int p,int r)
{
    if(p<r)
    {
        int q=RandomizedPartition(a,p,r);
        RandomizedQuickSort(a,p,q-1);//对左段排序
        RandomizedQuickSort(a,q+1,r);//对右段排序
    }
}

by author:Foredination

2018-02-05 15:46:10