快速排序、冒泡排序、堆排序、shell排序的递归和非递归实现

本文是我粗略写出来的一些测试程序仅在提供简单思路 ，可能一些递归条件还不充分，尽请谅解！

先来介绍最简单的冒泡排序：

一般我们的写法如下（稍微优化后）：

void bubble_sort(int a[],int lenth)
{
        if(a==NULL || lenth<1) return ;
        int change=0;
        for(int i=0;i<lenth-1;i++)
        {
                for(int j=lenth-2;j>=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<lenth)
        {
              for(int i=lenth-2;i>=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<lenth)
        {
                rc_swap(a,lenth,index,lenth-2);
                bubble_sort_cr(a,lenth,index+1);
        }
}

到此可以看出代码中已经没有循环。

下面是快速排序的递归实现：

//这个函数用来分划分，是公共部分
int partition(int a[],int low,int high)
{
        int key=a[low];
        while(low<high)
        {
                while(low<high && key<=a[high])high--;
                a[low]=a[high];
                while(low<high && key>=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<high)
        {
                int index=partition(a,low,high);
                quick_sort(a,low,index-1);
                quick_sort(a,index+1,high);
        }
}
/******************非递归实现**************************/
void quick_sort_noCR(int a[],int low,int high)
{
        stack<int> st;


        if(low<high)
        {
                int index=partition(a,low,high);
                if(low<index-1)
                {
                        st.push(low);
                        st.push(index-1);
                }
                if(index+1<high)
                {
                        st.push(index+1);
                        st.push(high);
                }
                while(!st.empty())
                {
                        int t=st.top();
                        st.pop();
                        int s=st.top();
                        st.pop();
                        index=partition(a,s,t);
                        if(s<index-1)
                        {
                                st.push(s);
                                st.push(index-1);
                        }
                        if(index+1<t)
                        {
                                st.push(index+1);
                                st.push(t);
                        }
                }


        }
}

堆排序的递归和非递归体现在对堆的调整过程

//堆排序的递归和非递归一并列出：
#include <iostream>
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(j<m && a[j]<a[j+1]) j++;
                if(rc>a[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(left<lenth)
        {
                largest = a[left]>a[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<lenth;i++)
        {
                cout<<a[i]<<" ";
        }
        cout<<endl;
}

int main()
{
        int a[]={45,54,21,76,8,43,9,0,65,43,23,73,51};
        int lenth=sizeof(a)/sizeof(a[0]);
        print(a,lenth);
        HAfun p=heapAdjust;
        //HAfun p=heapAdjust_rcs;
        heapSort(p,a,lenth);
        print(a,lenth);
        return 0;
}

下面是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<lenth;i++)
                {
                        int tmp=a[i];
                        int j=i-step;
                        for(;j>=0 && tmp<a[j];j-=step)
                        {
                                a[j+step]=a[j];
                        }
                        a[j+step]=tmp;
                }
        }
}

杨辉三角的打印：

//杨辉三角的每一行都符合从n个元素取出 0 - n/2 个元素的组合数的规律
#include <iostream>
using namespace std;
#define LINE 10
//此函数用于计从 n个元素中取出r个元素的组合数
long combi(int n,int r)
{
        if(n<r)return 0;
        long p=1;
        for(int i=1;i<=r;i++)
        {
                p=p*(n-i+1)/i;
        }
        return p;
}
int main(int argv,char* argc[])
{
        for(int n=0;n<LINE;n++)
        {
                for(int r=0;r<=n;r++)
                {
//此判断是为了对其
                        if(r==0)
                        {
                                for(int i=0;i<LINE-n;i++)
                                cout<<" ";
                        }
                        else
                        {
                                cout<<" ";
                        }
                        cout<<combi(n,r);
                }
                cout<<endl;
        }
}

the end ！