for循环里的递归，和双重递归

为了让大家更明白，我通过一个程序进行讲解，for循环递归

设计一个递归算法生成n个元素{r1,r2,…,rn}的全排列。

从n个不同元素中任取m(m≤n)个元素，按照一定的顺序排列起叫做从n个不同元素中取出m个元素的一个排列，当m=n时所有的排列情况叫全排列。

如1,2,3三个元素的全排列为：

1，2，3

1，3，2

2，1，3

2，3，1

3，1，2

3，2，1

#include <iostream.h>

template<typename T>

void Swap(T &a,T &b) //交换两个T类型的数

//T 可以是int 类型的  也可以是double类型的

{

    T temp;

    temp=a;

    a=b;

    b=temp;

}

template<typename T>

void Perm(T list[],int k,int m) {//产生list[k:m]的所有排列

//k,m都表示List的小标

    if(k==m) 

{

        for(int i=0; i<=m; i++) 

            cout<< list[i] << "   ";

        cout<<endl;

    }

    else

        for(int i=k; i<=m; i++) {

            Swap(list[k],list[i]);

            Perm(list,k+1,m);

            Swap(list[k],list[i]);

        }

}

int main()

{

    int list[]= {1,2,3};

    Perm(list,0,2);

    return 0;

}

分析一个程序应该从main方法开始

 

双重递归

 同样一以例子解析，首先强调一点，递归是方法嵌套的特例，如

Void f1(){  

f2();

f3(); 

}

Void f2()

{

……

}

Void f3()

{

……

}

这里我们知道，如果f2这个方法不返回的话，f3是不会被执行的，如果这个时候把f2()变成f1(),即和调用他的方法是一样的，即自己调用自己，这个时候就变成了递归，我们在分析递归程序的时候也要时刻注意这一点。

先上代码

 public static void mergerSort(int a[], int low, int high, int b[]) {  

            int mid = 0;  

             if (low < high) {

            mid = (high + low) / 2;// 分治位置,即将数组拆分的位置  

         

                //对左边一半进行递归

            mergerSort(a, low, mid, b);  //一直分，分到一个数字，占一个串

            

            mergerSort(a, mid + 1, high, b);  //一直分，分到一个数字，占一个串

                //进行归并

            merger(a, low, mid, high, b);// 合，合，合，合到一个大串里面

            }  

         

        }

 这是个双重递归，是归并排序里面的核心代码，所谓归并排序就是把一个长度为n的数组，分成N/2,分成2个有序子序列，然后再一直分，直到low=high,即就剩一个数字的时候，这个时候就不用排序了，为了让大家看的方便，给出merger的方法

  public static void merger(int[] a, int low, int mid, int high, int b[]) {  

          //左子串的起始位置

            int i = low; 

            //右子串的起始位置

            int j = mid + 1;  

            int p = 0;  

            // 合并两个有序数组 子序列1 a[low..mid] 子序列2 a[mid+1..high]  

            while (i <= mid && j <= high) {  //任何一个子序列到头了，都停止循环

                b[p++] = (a[i] <= a[j]) ? a[i++] : a[j++]; //都往后面移动一位 

            }  

            // 如果子序列1没有合并完则直接复制到复制数组中去  

            while (i <= mid) {  

                b[p++] = a[i++];  

            }  

            // 如果子序列2没有合并完则直接复制到复制数组中去  

            while (j <= high) {  

                b[p++] = a[j++];  

            }  

            // 把辅助数组的元素复制到原来的数组中去  

            for (p = 0, i = low; i <= high; i++, p++) {  

                a[i] = b[p];  

            }  

        }

//merger方法的作用是讲2个子序列排序，递归的时候会出现这么一个情况，low=0,high=1,在这个情况下，那就是a[0],与a[1]在排序了

在main方法里面测试上述代码

int a[] = { 25,14,53,32,64,45,92,78 };// 这里对8个元素进行排序  

            int low = 0, high = 7;// 初始化low和high的值，即数组的起始和终止的坐标  

            // 辅助数组b，作为临时数组  

            int b[] = new int[a.length];  

            //输出排序前的数组  

            System.out.print("排序前：");  

            for (int i = 0; i <= high; i++) {  

                System.out.print(a[i] + " ");  

            }  

            // 归并排序  

            System.out.println();

            mergerSort(a, low, high, b); 

            

            //输出排序后的数组  

            System.out.print("排序后：");  

            for (int i = 0; i <= high; i++) {  

                System.out.print(a[i] + " ");  

            }  

        }  

如果你还对整个归并排序的流程不懂的话，看图

为了表述方便，我们，称merger(a,l,m,h,b)方法为m(a,l,m,h,b);megersort(a,l,h,b)方法简写成ms(a,l,h,b);