快速排序算法分析和实现

快速排序的思想:

选择一个基准元素,比基准元素小的放基准元素的前面,比基准元素大的放基准元素的后面,这种动作叫分区,每次分区都把一个数列分成了两部分,每次分区都使得一个数字有序,然后将基准元素前面部分和后面部分继续分区,一直分区直到分区的区间中只有一个元素的时候,一个元素的序列肯定是有序的嘛,所以最后一个升序的序列就完成啦

但是关于基准元素的选择有两种

1.第一种是每次都选序列的子序列的第一个元素(有缺陷)

2.第二种是每次都选择子序列中的第x个元素,x随机

普通快速排序

代码如下:

 

#include<bits/stdc++.h>
using namespace std;
#define n 5
int a[n];
void swap_t(int a[],int i,int j)
{
    int t=a[i];
    a[i]=a[j];
    a[j]=t;
}
int par(int a[],int p,int q)
{
    int i=p;//p是轴
    int x=a[p];//基准元素
    for(int j=p+1;j<=q;j++)
    {
        if(a[j]<=x)//升序
        {
            i++;
            swap_t(a,i,j);
        }
    }
    swap_t(a,p,i);
    return i;//轴位置
}
void QuickSort(int a[],int p,int q)
{
    if(p<q)//序列中元素个数大于1
    {
        int r=par(a,p,q);
        QuickSort(a,p,r-1);
        QuickSort(a,r+1,q);
    }
}
int main()
{
    int i;
    for(i=0;i<n;i++)
    {
        scanf("%d",&a[i]);
    }
    QuickSort(a,0,n-1);
    for(i=0;i<n;i++)
    {
        printf("%d\n",a[i]);
    }
    return 0;
}
View Code

算法分析:

1.最好情况:(每次分区时子序列中元素个数相同)

T(n)=2T(n/2)+O(n)=O(n*logn) log的底是2

2.最坏情况:序列是由大到小排序的

比如:7 6 5 4 3 2 1   -----> ( 进行依次分区,基准元素是7)  1 6 5 4 3 2 7,元素7的后面是没有元素的,同理 再将序列1 6 5 4 3 2分区,变成了1 2 5 4 3 6,分区6的后面也是没有元素的(7不属于这个分区),所以最坏情况的快速排序相当于冒泡排序了。。。。。。。有没有一种操蛋的感觉

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

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

      继续变形下去

      T(常数)可以去掉

     T(n)=O(1)+O(2)+.......+O(n)//等差数列求和

      T(n)=O((1+n)*n/2)=n*n //常数可以省略

所以T(n)=n*n

3.一般情况:

T(n)=T(n/5)+T(4*n/5)+O(n) //假设前面分成1份后面分成4份这种情况

      =T(n/25)+T(4*n/25)+O(n/5)+T(4*n/25)+T(16*n/25)+O(4*n/5) 

我们假设T(n/5) 和T(4*n/5)展开成一颗树的形状,经过一系列比较复杂的推导之后(不好描述。。。。。)得到树的最大深度是log 5/4 n(底数的5/4),然后log 5/4 n 经过数学等价变形为log 2 n(底数为2)

然后又经过一系列复杂推导后(。。。。。。。。。。),树的最大宽度为:n

所以T(n)=n*log 2 n(底数为2)

总结:普通快排存在缺陷,缺陷在于每次基准元素的选择

二,改进之后的快速排序:随机化快速排序(每次随机在序列中选择基准元素),因为快排的性能取决于划分的对称性

附加知识:生成p,q之间的随机数:

方法:先生成随机数n,int i=n%(q-p+1)+p ,i就是p,q之间的随机数

代码如下:

#include<bits/stdc++.h>
using namespace std;
#define n 5
int a[n];
void swap_t(int a[],int i,int j)
{
    int t=a[i];
    a[i]=a[j];
    a[j]=t;
}
int par(int a[],int p,int q)
{
    int i=p;//p是轴
    int x=a[p];
    for(int j=p+1;j<=q;j++)
    {
        if(a[j]<=x)
        {
            i++;
            swap_t(a,i,j);
        }
    }
    swap_t(a,p,i);
    return i;//轴位置
}
int Random(int p,int q)
{
    return rand()%(q-p+1)+p;
}
int Randomizedpar(int a[],int p,int q)
{
    int i=Random(p,q);
    swap_t(a,p,i);//第一个和第i个交换,相当于有了一个随机基准元素
    return par(a,p,q);
}
void RandomizedQuickSort(int a[],int p,int q)
{
    if(p<q)
    {
        int r=Randomizedpar(a,p,q);
        printf("%d到%d之间的随机数:%d\n",p,q,r);
        RandomizedQuickSort(a,p,r-1);
        RandomizedQuickSort(a,r+1,q);
    }
}
int main()
{
    int i;
    for(i=0;i<n;i++)
    {
        scanf("%d",&a[i]);
    }
    RandomizedQuickSort(a,0,n-1);
    for(i=0;i<n;i++)
    {
        printf("%d\n",a[i]);
    }
    return 0;
}
View Code

总结:快排虽然不稳定,但是高效(关于不稳定的概念请百度。。。)

    

有错误的地方麻烦大佬们指正!!!

 

posted @ 2018-04-12 19:37  西*风  阅读(1358)  评论(0编辑  收藏  举报