快排递归非递归

#include <iostream>
using namespace std;

int partition(int *a, int l, int h)
{
	int x = a[l];
	int i = l;
	int j = h+1;
	int temp;
	
	while (i<j)
	{
		while (a[++i]<x&&i<h);
		while(a[--j]>x);
		if (i<j)
		{
			temp = a[i];
			a[i] = a[j];
			a[j] = temp;
		}
	}

	a[l] = a[j];
	a[j] = x;
	return j;
}

void qsort(int *a, int l, int h)
{
	if(l>=h)
		return;
	
	int q = partition(a, l, h);
	
	qsort(a, l, q-1);

	qsort(a, q+1, h);
}

int main()
{
	int a[9] = {9,8,7,6,5,4,3,2,1};
	qsort(a,0,8);
	
	for(int i=0; i<9; i++)
		cout<<a[i]<<endl;
	
	return 0;
}


//非递归算法
//数据规模很大时，递归的算法很容易导致栈溢出，改为非递归，模拟栈操作，最大长度为n，每次压栈时先压长度较大的，此时栈深度为logn。
#include <iostream>
using namespace std;

int partition(int *a, int l, int h)
{
	int x = a[l];
	int i = l;
	int j = h+1;
	int temp;
	
	while (i<j)
	{
		while (a[++i]<x&&i<h);
		while(a[--j]>x);
		
		if (i<j)
		{
			temp = a[i];
			a[i] = a[j];
			a[j] = temp;
		}
	}
	
	a[l] = a[j];
	a[j] = x;

	return j;
}

void qsort(int *a, int l, int h)
{
	if (l>=h)
		return;

	int *s = new int[h-l+1];
	int p = 0;
	s[p++] = l;
	s[p++] = h;

	int low,high,q;

	while (p>0)
	{
		high = s[--p];
		low = s[--p];
		if (low>=high)
			break;
	
		q = partition(a, low, high);
 
		if (q-low > high-q)
		{
			s[p++] = low;
			s[p++] = q-1;

			if (high > q)
			{
				s[p++] = q+1;
				s[p++] = high;
			}

		}
		else
		{
			s[p++] = q+1;
			s[p++] = high;
			if (q > low)
			{
				s[p++] = low;
				s[p++] = q-1;
			}
		}
	}
	delete []s;
}

int main()
{
	int a[9] = {9,8,7,6,5,4,3,2,1};
	//int a[9] = {1,2,3,4,5,6,7,8,9};
	qsort(a,0,8);
	 
	for (int i=0; i<9; i++)
		cout<<a[i]<<endl;

	return 0;
}

//******************快速排序非递归算法（队列实现）*****************************
const int Maxsize = 100;

void quicksortu(int a[],int n)
{  
struct node
{
	int low,high;
}qu[Maxsize]; 

	int i,j,low,high,temp,front=-1,rear=-1;

     rear++;
     qu[rear].low=0;
	 qu[rear].high=n-1;

     while(front!=rear)
     {   
		 front=(front+1)%Maxsize;
         low=qu[front].low;
		 high=qu[front].high;
         i=low;
		 j=high;
         if(low<high)
         {    temp=a[low];
             while(i!=j)
             {    while(i<j&&a[j]>temp)j--;
                 if(i<j){a[i]=a[j];i++;}
                 while(i<j&&a[i]<temp)i++;
                 if(i<j){a[j]=a[i];j--;}
             }
             a[i]=temp;

             rear=(rear+1)%Maxsize;
			 qu[rear].low=low;
			 qu[rear].high=i-1;

             rear=(rear+1)%Maxsize;
			 qu[rear].low=i+1;
			 qu[rear].high=high;
         }
     }
}

struct node 
{
	int low,high;
}st[100];
//******************快速排序非递归算法（堆栈实现）*****************************
void quicksort(int a[],int n)
{      int i,j,low,high,temp,top=0;

       
       st[top].low=0;
	   st[top].high=n-1;
       while(top>-1)
       {   low=st[top].low;
	       high=st[top].high;
           top--;
           i=low;
		   j=high;
           if(low<high)
           {   temp=a[low];
               while(i!=j)
               {   while(i<j&&a[j]>temp)j--;
                   if(i<j){a[i]=a[j];i++;}
                   while(i<j&&a[i]<temp)i++;
                   if(i<j){a[j]=a[i];j--;}
               }
               a[i]=temp;

               top++;  
			   st[top].low=low;   
			   st[top].high=i-1;

               top++;  
			   st[top].low=i+1;   
			   st[top].high=high;
           }
       }
}