1.累加
首先让我们先了解递归:递归,就是在运行的过程中调用自己。
我们知道递归必须具备两个条件,一个是调用自己,一个是有终止条件。这两个条件必须同时具备,且一个都不能少。并且终止条件必须是在递归最开始的地方。
先看老师代码
#include <stdio.h>
/**
* Recursive addition.
*/
int addTo(int paraN) {
int tempSum;
printf("entering addTo(%d)\r\n", paraN);
if (paraN <= 0) {
printf(" return 0\r\n");
return 0;
} else {
tempSum = addTo(paraN - 1) + paraN;
printf(" return %d\r\n", tempSum);
return tempSum;
}// Of if
}// Of addTo
/**
* A clear version.
*/
int clearAddTo(int paraN) {
if (paraN <= 0) {
return 0;
} else {
return clearAddTo(paraN - 1) + paraN;
}// Of if
}// Of clearAddTo
/**
* Test the addTo function.
*/
void addToTest() {
int n, sum;
printf("---- addToTest begins. ----\r\n");
n = 5;
sum = addTo(n);
printf("\r\n0 adds to %d gets %d.\r\n", n, sum);
n = 1;
sum = addTo(n);
printf("\r\n0 adds to %d gets %d.\r\n", n, sum);
n = -1;
sum = addTo(n);
printf("\r\n0 adds to %d gets %d.\r\n", n, sum);
printf("---- addToTest ends. ----\r\n");
}// Of addToTest
/**
The entrance.
*/
void main() {
addToTest();
}// Of main
运行结果
---- addToTest begins. ----
entering addTo(5)
entering addTo(4)
entering addTo(3)
entering addTo(2)
entering addTo(1)
entering addTo(0)
return 0
return 1
return 3
return 6
return 10
return 15
0 adds to 5 gets 15.
entering addTo(1)
entering addTo(0)
return 0
return 1
0 adds to 1 gets 1.
entering addTo(-1)
return 0
0 adds to -1 gets 0.
---- addToTest ends. ----
Press any key to continue
自己写的
#include<stdio.h>
#include<malloc.h>
int addTo(int n) {
int sum;
if (n <=0) {
return 0;
}
else {
sum = addTo(n - 1) + n;
return sum;
}
}
int main() {
int sum;
sum = addTo(5);
printf("%d\r\n", sum);
}
2.汉诺塔问题
汉诺塔问题是一个经典的问题。汉诺塔(Hanoi Tower),又称河内塔,源于印度一个古老传说。大梵天创造世界的时候做了三根金刚石柱子,在一根柱子上从下往上按照大小顺序摞着64片黄金圆盘。大梵天命令婆罗门把圆盘从下面开始按大小顺序重新摆放在另一根柱子上。并且规定,任何时候,在小圆盘上都不能放大圆盘,且在三根柱子之间一次只能移动一个圆盘。问应该如何操作?
先看老师代码
#include <stdio.h>
/**
* Hanoi.
*/
void hanoi(int paraN, char paraSource, char paraDestination, char paraTransit) {
if (paraN <= 0) {
return;
} else {
hanoi(paraN - 1, paraSource, paraTransit, paraDestination);
printf("%c -> %c \r\n", paraSource, paraDestination);
hanoi(paraN - 1, paraTransit, paraDestination, paraSource);
}// Of if
}// Of hanoi
/**
* Test the hanoi function.
*/
void hanoiTest() {
printf("---- addToTest begins. ----\r\n");
printf("2 plates\r\n");
hanoi(2, 'A', 'B', 'C');
printf("3 plates\r\n");
hanoi(3, 'A', 'B', 'C');
printf("---- addToTest ends. ----\r\n");
}// Of addToTest
/**
The entrance.
*/
void main() {
hanoiTest();
}// Of main
运行结果
---- addToTest begins. ----
2 plates
A -> C
A -> B
C -> B
3 plates
A -> B
A -> C
B -> C
A -> B
C -> A
C -> B
A -> B
---- addToTest ends. ----
Press any key to continue
自己做的
//汉诺塔问题,打印的是整个的移动过程
#include <stdio.h>
void hanoi(int n , char A , char B , char C)//n个圈圈在柱子A上,借助柱子B,移动到柱子C上
{
if(n == 1)//如果A柱子上只有一个圈圈,直接移动到C上
printf("%c---->%c\n",A,C);
else
{
hanoi(n-1,A,C,B);//将A柱子上的n-1个圈圈,借助柱子C,移动到柱子B上
printf("%c---->%c\n",A,C);//将A柱子上的最后一个圈圈移动到柱子C上
hanoi(n-1,B,A,C);//将B柱子上的n-1个圈圈,借助柱子A,移动到柱子C上
}
}
int main()
{
int n;
scanf("%d",&n);
hanoi(n,'A','B','C');
return 0;
}
总结:hanoi(n - 1, a, c, b)函数的实参a,b和c并不是总对应A盘,B盘和C盘并且在传递给形参后abc对应的值会发生变化,但是确是有规律的在变化,为什要了解这个呢?因为这个hanoi函数的形参对应的值会影响move函数的打印。规律为形参abc对应值为ACB,ABC循环变化,再加上第一次调用hanoi函数形参abc对应ABC,这也就解释了为什么奇数个盘子时第一步永远为A–>C,而偶数个时,第一步永远为A–>B