快速排序

分治之快速排序

#include <stdio.h>
#include <stdlib.h>

void swap(int a[],int i,int j)
{
   
    int t;
    t=a[i];
    a[i]=a[j];
    a[j]=t;
}
int partition(int a[],int p,int q)
{
   
    int x=a[p];
    int i=p,j;
    for(j=p+1;j<=q;j++)
    {
   
       if(a[j]<=x)
       {
   
           i++;
           swap(a,i,j);
       }
    }
    swap(a,p,i);
    return i;
}
void qiucksort(int a[],int p,int q)
{
   
    if(p<q)
    {
   
        int r=partition(a,p,q);
        qiucksort(a,p,r-1);
        qiucksort(a,r+1,q);
    }
}
int main()
{
   
    int n,a[1005],i;
    while(~scanf("%d",&n))
    {
   
      for(i=0;i<n;i++)
            scanf("%d",&a[i]);
       qiucksort(a,0,n-1);
      for(i=0;i<n;i++)
        printf("%d ",a[i]);
      printf("\n");
    }
    return 0;
}

这是基本的快速排序，但是快速排序的时间复杂度在数组是有序时的时间复杂度是O（n^2），这时的时间复杂度和冒泡排序的时间复杂度是一样的，也就是快排的最坏情况，那么我们应该如何优化算法让其最快的时间复杂度也是O（nlogn）呢？

这里我们需要拓展一个小知识点，已知rand（）函数可以随机生成一个非负整数，请问如何得到一个[a，b]之间的随机非负整数呢？

用rand（）%（b-a+1）+a就可以得到在[a，b]之间的随机非负整数了

那么优化后的快速排序代码如下

#include <iostream>

using namespace std;
void swap(int a[],int i,int j)
{
    int t;
    t=a[i];
    a[i]=a[j];
    a[j]=t;
}
int random(int p,int q)
{
    return rand()%(q-p+1)+p;
}
int partition(int a[],int p,int q)
{
    int x=a[p];
    int i=p,j;
    for(j=p+1;j<=q;j++)
    {
       if(a[j]<=x)
       {
           i++;
           swap(a,i,j);
       }
    }
    swap(a,p,i);
    return i;
}
int randompartition(int a[],int p,int q)
{
    int r=random(p,q);
    swap(a,p,r);
    int i=partition(a,p,q);
    return i;
}
void qiucksort(int a[],int p,int q)
{
    if(p<q)
    {
        int r=randompartition(a,p,q);
        qiucksort(a,p,r-1);
        qiucksort(a,r+1,q);
    }
}

int main()
{
    int n,a[1005],i;
    while(~scanf("%d",&n))
    {
      for(i=0;i<n;i++)
            scanf("%d",&a[i]);
       qiucksort(a,0,n-1);
      for(i=0;i<n;i++)
        printf("%d ",a[i]);
      printf("\n");
    }
    return 0;
}