快速排序、冒泡排序、堆排序、shell排序的递归和非递归实现
本文是我粗略写出来的一些测试程序仅在提供简单思路 ，可能一些递归条件还不充分，尽请谅解！
先来介绍最简单的冒泡排序：
一般我们的写法如下（稍微优化后）：
void bubble_sort(int a[],int lenth)
{
if(a==NULL || lenth<1) return ;
int change=0;
for(int i=0;i=i;j--)
{
if(a[j]>a[j+1])
{
a[j]=a[j]^a[j+1];
a[j+1]=a[j]^a[j+1];
a[j]=a[j]^a[j+1];
change=1;
}
}
if(change==0)return ;
}
} 下面用一个递归代替一个循环：
//**************************************************
a - 要排序数组头指针
lenth - 数组长度
index - 可以看成非递归方法中的 i 变量
**************************************************/
void bubble_sort_cr(int a[],int& lenth,int index)
{
if(index=index;i--)
{
if(a[i]>a[i+1])
{
a[i]^=a[i+1];
a[i+1]^=a[i];
a[i]^=a[i+1];
}
}
bubble_sort_cr(a,lenth,index+1);
}
} 可以看出其中只有一个循环。
下面再用一个递归函数代替循环变变量：
/**********************recursion method for bubble sort*******************************
a - 要排序数组头指针
lenth - 数组长度
index - 可以看成非递归方法中的 i 变量
cur - 可以看作一个循环方法中的 i 变量
***************************************************************************************/
void rc_swap(int a[],int& lenth,int& index,int cur)
{
if(index<=cur)
{
if(a[cur]>a[cur+1])
{
a[cur]^=a[cur+1];
a[cur+1]^=a[cur];
a[cur]^=a[cur+1];
}
rc_swap(int a[],lenth,index,cur-1);
}
}
void bubble_sort_cr(int a[],int& lenth,int index)
{
if(index到此可以看出代码中已经没有循环。
下面是快速排序的递归实现：
//这个函数用来分划分，是公共部分
int partition(int a[],int low,int high)
{
int key=a[low];
while(low=a[low])low++;
a[high]=a[low];
}
a[low]=key;
return low;
}
/*****************递归实现*******************************/
/**********recursion method ************/
void quick_sort(int a[],int low,int high)
{
if(low st;
if(low 堆排序的递归和非递归体现在对堆的调整过程
//堆排序的递归和非递归一并列出：
#include
using namespace std;
typedef void (*HAfun)(int a[],int s,int lenth);
/***************heap sort non recursion*************************
arry - the arrary which we want to sort
s- start index
m- end index
the arry meet with big top heap except arry[s]
so we should adjust the heap to a real big top heap
***************************************************************/
void heapAdjust(int a[],int s,int m)
{
int rc=a[s];
for(int j=2*s+1;j<=m;j=2*j+1)
{
if(ja[j])break;
a[s]=a[j];
s=j;
}
a[s]=rc;
}
/**********************heap srot recursion*****************************
arry - the arrary which we want to sort
s- start index
m- end index
the arry meet with big top heap except arry[s]
so we should adjust the heap to a real big top heap
***************************************************************/
void heapAdjust_rcs(int a[],int s,int& lenth)
{
int largest=s;
int left=(s<<1)+1;
int right=(s<<1)+2;
if(lefta[right]?left:right;
largest = a[largest]>a[s]?largest:s;
}
if(left==lenth)
{
largest= a[left]>a[largest]?left:largest;
}
if(largest!=s)
{
a[s] ^= a[largest];
a[largest] ^= a[s];
a[s] ^= a[largest];
heapAdjust_rcs(a,largest,lenth);
}
}
/********************************************************************
heapAdjustfun - the function point which can reference to #define
a - arrary to sort
lenth - the length of arrary
*******************************************************************/
void heapSort(HAfun heapAdjust ,int a[],int& lenth)
{
for(int i=(lenth-1)/2;i>=0;--i)
{
heapAdjust(a,i,lenth-1);
}
for(int i=lenth-1;i>=1;--i)
{
a[0] ^= a[i];
a[i] ^= a[0];
a[0] ^= a[i];
heapAdjust(a,0,i-1);
}
}
/************************************************************************/
void print(int a[],int lenth)
{
for(int i=0;i 下面是shell排序：
void shell_sort(int a[],int lenth)
{
if(a==NULL||lenth<=1)return ;
for(int step=lenth/2;step>0;step/=2)
{
for(int i=step;i=0 && tmp //杨辉三角的每一行都符合从n个元素取出 0 - n/2 个元素的组合数的规律
#include
using namespace std;
#define LINE 10
//此函数用于计从 n个元素中取出r个元素的组合数
long combi(int n,int r)
{
if(n the end ！