（九十八）递归（函数与函数自己）

递归的实质，函数自己调用自己。——但C++语言不允许main函数调用自己

 

包含一个递归调用的递归：

例如代码：

#include<iostream>
using namespace std;

int m(int);	//m函数

int main()
{
	int a = 0;
	a = m(a);	//函数参数为a，并将返回值赋值给a
	cout << a << endl;
	system("pause");
	return 0;
}

int m(int a)
{
	a++;	//a+1
	if (a < 10) m(a);	//当a<10的时候，调用函数m，参数为a，注意，ma的返回值不影响if判断语句中的a<10。
	cout << "a = " << a << endl;	//输出本函数的值
	return a;
}

输出：

a = 10
a = 9
a = 8
a = 7
a = 6
a = 5
a = 4
a = 3
a = 2
a = 1
1
请按任意键继续. . .

解释：

①在m函数中（这时候是最外层的m），a++后，a=1；又因为1<10，于是执行m函数（第二层m函数），参数是a=1；

第二层m函数，参数是a=1，a++后a=2，2<10，于是执行m函数（第三层m函数），参数是a=2；

依次类推……

 

第九层m函数，参数是a=9，a++后a=10，if判断语句不通过，于是执行下一行代码，打印a=10；然后第九层函数执行完，跳回第八层函数，返回值是10（但第八层函数并没有接收这个返回值）；

第八层函数的if语句执行结束（已经调用完第九层函数），此时a=9，打印a=9，跳回第七层函数；

依次类推……

 

第一层（最外层）m函数，此时a=1，返回值是a（1），于是main函数中a=1；

 

②假如没有a++这行代码，函数就会陷入无限循环之中。

 

另一代码：打印缩进图形的星：

//打印从两边缩进的星
#include<iostream>

using namespace std;
const int kuan = 20;
char zifu[kuan];
void ab(char,int);	//无返回值函数，参数为char

int main()
{
	char x = '*';
	for (int i = 0;i < kuan;i++)
		zifu[i] = ' ';
	ab(x, 20);

	system("pause");
	return 0;
}

void ab(char m,int n)
{
	zifu[kuan - n] = m;
	zifu[n - 1] = m;
	for (int i = 0;i < kuan;i++)
		cout << zifu[i];
	cout << endl;
	n--;
	if (n > kuan / 2)ab(m, n);
}

输出：

*                  *
**                **
***              ***
****            ****
*****          *****
******        ******
*******      *******
********    ********
*********  *********
********************
请按任意键继续. . .

包含多个递归调用的递归：

因为多个递归可以多次调用自己，因此需要一个变量可以控制调用的次数，并且这个变量在每次调用的时候，可以增加或者减少，以满足停止调用的条件。

 

 

如代码：

#include<iostream>

const int kuan = 66;
const int dives = 5;
void shu(char ar[], int low, int high, int level);

int main()
{
	char ruler[kuan];	//字符串宽
	int i;	//初始化i，因为在其他地方也要用i，所以在for外面初始化
	for (i = 1;i < kuan - 2;i++)
		ruler[i] = ' ';	//从第2个字符到倒数第二个字符，都是空格
	ruler[kuan - 1] = '\0';	//最后一个字符为空字符（因为是字符串）
	int max = kuan - 2;	//max是字符宽度-2（这样将指示倒数第二个字符）
	int min = 0;	//min是0，
	ruler[min] = ruler[max] = '|';	//第一个和倒数第二个字符是|，注意，最后一个是空字符
	std::cout << ruler << std::endl;	//输出字符串，这个时候第一个和倒数第二个是|，其他是空格

	for (i = 1;i <= dives;i++)
	{
		shu(ruler, min, max, i);	//调用函数，参数是字符串，min，max，
		std::cout << ruler << std::endl;	//输出字符串
		for (int j = 1;j < kuan - 2;j++)	//重置字符串为空字符，注意，没清楚字符串第一个字符和倒数第二个字符
			ruler[j] = ' ';	
	}
	system("Pause");
	return 0;
}

void shu(char ar[], int low, int high, int level)
{
	if (level == 0)	//当level为0时，结束函数，level初始为for循环中的i
		return;
	int mid = (high + low) / 2;	//min是high和low的平均数，即为中间
	ar[mid] = '|';	//中间为|，
	shu(ar, low, mid, level - 1);	//执行函数，level-1，mid替代high为参数，即层次每高1级，即可在low和mid中间的位置插入一个字符|
	shu(ar, mid, high, level - 1);	//在mid和high中间插入一个字符。
}

输出：

|                                                               |
|                               |                               |
|               |               |               |               |
|       |       |       |       |       |       |       |       |
|   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | |
请按任意键继续. . .

解释：

①控制函数层级的是level，每次函数自己调用自己的时候，level将-1，当level=0时，函数直接返回（即这次调用结束）；

 

②初始level为for循环中的i，第一次是i=0，因此函数直接返回；

当for循环进入i=1时，函数执行第一次，并且在函数自己调用自己的时候，level-1的值为0，调用后，函数直接返回；

当for循环进入i=2时，函数执行第一次，然后函数在自己调用自己的时候，level-1的值为1，因此函数执行第一次的时候，可以调用自己两次，加上函数第一次，共执行三次（即多出三个“|”）；

当for循环进入i=3时，同i=2，但此时是三层函数，执行1+2+4=7次，即多出7个“|”。

依次类推。

 

③函数的特点是，定出左边的字符和最右边字符的位置，然后给中间字符赋值字符“|”。

并且以中间位置，为下一次调用函数时的最左边或者最右边位置。

 

即第一轮是1#（ar[0]）和64#（ar[63]）位置有字符；（调用0次函数）

第二轮时1#，64#以及他们中间的位置32#（ar[31]）位置有字符；（调用1次函数）

第三轮，除了第二轮的三个，还在1#和32#、32#和64#中间有字符，即16#和48#；（调用1+2次函数）

第四轮，除了第三轮的5个，还分别在1和16，16和32，32和48，48和64中间有字符；（调用1+2+4次函数）

 

即每次都在上一次有字符的位置中间，有字符。

而level是用来控制轮数的。

 

方向向右的树形图，多重递归的代码：

//思路：
//创建二维字符串，即string[y][x]，描述坐标上的点，然后给坐标上的点赋值（“—”或者空字符）
//用多重递归，使得图形为向右的树形图；
//赋值完毕后，打印二维字符串

#include<iostream>
#include<string>
using namespace std;

void shuxingtu(string a[][32], int x, int y);

int main()
{
	//首先是给树形图赋值，预计树形图为
	string a[32][32];
	int x ,y;
	x = y = 0;
	for (int i = 0;i < 32;i++)	//使得32x32的坐标都是空字符
		for (int j = 0;j < 32;j++)
			a[i][j] = ' ';
	y = 16;
	a[y][x] = "*";

	x = 1;
	shuxingtu(a, x, y);	//给二维string字符串赋值

	//打印字符串
	for (int i = 0;i < 32;i++)	//使得32x32的坐标都是空字符
	{
		for (int j = 0;j < 32;j++)
			cout << a[i][j];
		cout << endl;
	}

	system("pause");
	return 0;
}

void shuxingtu(string a[][32], int x, int y)	//导入二维string字符串数组，导入x，y坐标
{
	if (x == 16)return;	//当层级为0时，结束循环
	//注意，导入坐标的点，不赋值——即保持为空字符，导入坐标上下方的点赋值*
	a[y + 1][x] = "*";	//上一个y更高一个位置
	a[y - 1][x] = "*";	//上一个y更低一个位置
	shuxingtu(a, x + 1, y + 1);	//再次调用的时候，x坐标+1，y坐标+1（即是调用本函数赋值的两个点往右边一位）
	shuxingtu(a, x + 1, y - 1);	//再次调用的时候，x坐标+1，y坐标-1（注意，当前函数所赋值*的点为x，y-1与x，y+1
}

输出：

               *
              *
             * *
            * *
           * * *
          * * *
         * * * *
        * * * *
       * * * * *
      * * * * *
     * * * * * *
    * * * * * *
   * * * * * * *
  * * * * * * *
 * * * * * * * *
* * * * * * * *
 * * * * * * * *
  * * * * * * *
   * * * * * * *
    * * * * * *
     * * * * * *
      * * * * *
       * * * * *
        * * * *
         * * * *
          * * *
           * * *
            * *
             * *
              *
               *
请按任意键继续. . .

解释：

①如果看以上图标排列不整齐，可能是因为字体问题。

 

②从左边中间开始，赋值“*”，然后x坐标+1，y+1和y-1位置上的点赋值“*”。并以此类推。