快排的三种实现，以及三种实现运算速度的比较 c语言

实测

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;
}