实测
1.递归排序200万int型数据运行5次各0.906000秒,0.921000,0.891000,0.906000,0.891000,平均为0.903秒
2.非递归2排序需0.875000,0.828000,0.906000,0.813000,0.797000,平均为0.843秒
3.非递归1运用了实际的栈,这个太慢了,之前试过1万个数,用了20多秒。这又来测试200万个int型整数,我只能呵呵,所以这个我就没测,大家自己测
总结:
非递归1用了数据结构上的栈,还能再慢点吗
对于1,递归用了903毫秒,已经很快了,以前老师讲课时说递归很慢,今天测试后感觉不慢,很快,比我想象的快的不是一星半点。但是递归调用函数,浪费空间,递归太深容易造成堆栈溢出。
对于2,它的时间花费主要在循环上,To be number one
直接上代码:
以下为quick_sort.c文件
#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#include"stack.h"
#define N 2000000 //数组长度
#define M 50000 //数组成员的大小
int main(int argc,char* argv)
{//快排的递归和非递归算法1,非递归2
void quick_sort_recursion(int arr[],int left,int right);
void quick_sort_nonrecursion1(int arr[],int left,int right);//非递归1,借助实际上的栈
void quick_sort_nonrecursion2(int arr[],int left,int right);//非递归2,借助理论上的栈
int partition(int arr[],int left,int right);
void init_array(int arr[],int n);
void show_array(int arr[],int n);
//
int arr[N];
clock_t begin,end;
double time;
init_array(arr,N);
// show_array(arr,N);
begin=clock();
quick_sort_recursion(arr,0,N-1);//0.094
// quick_sort_nonrecursion1(arr,0,N-1);
// quick_sort_nonrecursion2(arr,0,N-1);//0.078
end=clock();
time=(double)(end-begin)/CLOCKS_PER_SEC;
// show_array(arr,N);
printf("%f\n",time);
//
system("pause");
return 0;
}
void quick_sort_recursion(int arr[],int left,int right)
{
if(left<right)
{
int mid;
mid=partition(arr,left,right);
quick_sort_recursion(arr,left,mid-1);
quick_sort_recursion(arr,mid+1,right);
}
}
int partition(int arr[],int left,int right)
{
int temp=arr[left];
while(left<right)
{
while(left<right&&arr[right]>=temp)
{
right--;
}
arr[left]=arr[right];
while(left<right&&arr[left]<=temp)
{
left++;
}
arr[right]=arr[left];
}
arr[right]=temp;//此时left==right
return right;
}
void init_array(int arr[],int n)
{
int i;
// srand(time(NULL));
for(i=0;i<n;i++)
arr[i]=rand()%M;
}
void show_array(int arr[],int n)
{
int i;
for(i=0;i<n;i++)
{
printf("%d ",arr[i]);
}
printf("\n");
}
void quick_sort_nonrecursion1(int arr[],int left,int right)
{
stack st;
int mid;
int i,j;
init_stack(&st);
if(left<right)
{
push(&st,left);
push(&st,right);
while(!stack_empty(st))
{
pop(&st,&j);
pop(&st,&i);
mid=partition(arr,i,j);
if(i<mid-1)
{
push(&st,i);
push(&st,j);
}
if(j>mid+1)
{
push(&st,mid+1);
push(&st,j);
}
}
}
}
void quick_sort_nonrecursion2(int arr[],int left,int right)
{
int st[100];//栈的大小
int top=1;//当top=-1时,栈空
int mid;
int i,j;
st[0]=left;
st[1]=right;
while(top!=-1&&top<100)
{
// printf("%d\t",top);
j=st[top--];
i=st[top--];
mid=partition(arr,i,j);
if(i<mid-1)
{
st[++top]=i;
st[++top]=mid-1;
}
if(j>mid+1)//判定条件为j>mid+1
{
st[++top]=mid+1;
st[++top]=j;
}
}
}
以下为stack.h文件:
#define STACK_SIZE 100
typedef struct
{
int data[STACK_SIZE];
int top;
}stack;
void init_stack(stack* st)
{
st->top=-1;
}
int stack_empty(stack st)
{
if(st.top==-1)
return 1;
else
return 0;
}
int push(stack* st,int a)
{
if(st->top==STACK_SIZE-1)
return 0;
st->data[++(st->top)]=a;
return 1;
}
int pop(stack* st,int* a)
{
if(st->top==-1)
return 0;
*a=st->data[st->top--];
return 1;
}
int get_top(stack st,int* a)
{
if(st.top==-1)
return 0;
*a=st.data[st.top];
return 1;
}