重温c语言之，7天开整，就是随便的写写，第八天

一：函数

　　1、递归

　　题目：求n的阶乘（不考虑溢出）

　　上代码

 1 #include<stdio.h>
 2 int factorial(int n) {
 3     if (n > 1) {
 4         return n * (factorial(n - 1));
 5     }
 6     else
 7     {
 8         return 1;
 9     }
10 }
11 #include<stdio.h>
12 int main()
13 {
14     int num = 0;
15     printf("请打出想要输出的数的阶乘：");
16     scanf("%d", &num);
17     int ret=factorial(num);
18     printf("%d\n", ret);
19     return 0;
20 }

　　这里就是：运用了阶乘运算的思想，

　　1！=1*1

　　2！=2*1！

　　3！=3*2！

　　4！=4*3！

　　·······

　　n！=n*（n-1）！

　　所以这里就是运用这个想法来将运行的步骤进行简略，从而使代码变成2行

　　斐波那契数列：

 1 //斐波那契数列:f(n)=f(n-1)+f(n-2);
 2 // 1,1,2,3,5,8,13,21,34,55
 3 //求第n个斐波那契数
 4 int sequence(int n) {
 5     int ret = 0;
 6     if (n > 2) {
 7         ret = sequence(n - 1) + sequence(n - 2);
 8     }
 9     else
10     {
11         ret = 1;
12     }
13     return ret;
14 }
15 #include<stdio.h>
16 int    main() {
17     int num = 0;
18     printf("请输入一个数字：");
19     scanf("%d", &num);
20     printf("这个数字的斐波那契值是：%d\n", sequence(num));
21     return 0;
22 }

　　这里还有一个非常经典的递归题目：汉诺塔

　　从左到右有A、B、C三根柱子，其中A柱子上面有从小叠到大的n个圆盘，现要求将A柱子上的圆盘移到C柱子上去，期间只有一个原则：一次只能移到一个盘子且大盘子不能在小盘子上面，求移动的步骤和移动的次数

　　先上代码，然后解释

 1 #include<stdio.h>
 2 //n代表的是盘子数量
 3 //a是起始位置
 4 //b是中间位置
 5 //c是最终位置
 6 int move_cout = 0;
 7 void move(char a, char c) {
 8     printf("%c-->%c ", a, c);
 9     move_cout++;
10 }
11 void Hanoi(int n,char a,char b,char c) {
12     
13     if (n==1)
14     {
15         move(a, c);
16     }
17     else
18     {
19         Hanoi(n-1, a, c, b);
20         move(a, c);
21         Hanoi(n - 1, b, a, c);
22     }
23 
24 }
25 int main()
26 {
27     int n = 0;
28     printf("请输入A盘上有多少个盘子：");
29     scanf("%d", &n);
30     Hanoi(n,'A','B','C');
31     printf("\n%d\n", move_cout);
32     return 0;
33 }

　　这里先想，如果只有一个盘子，那会发生什么：A-->C，将a上面的盘子直接移动到c上面

　　再想，如果a上面有2个盘子呢，A-->B， A-->C ，B-->C，先将a最上面的盘子移动到c，再将a上面的盘子移动到c盘，最后将b盘上面的盘子移动到c盘

　　再次想象，如果a上面有3个盘子呢，A-->C， A-->B， C-->B， A-->C， B-->A， B-->C， A-->C，现将a最上面的盘子移动到c，再将a里面的第二个盘子移动到b，再讲c里面的盘子移动到b，之后就把a上面最后一个盘子移动到c，然后将b上面的盘子移动到a，之后再将b的盘子移动到c，最后将a的盘子移动到c，完成移动

　　由此可得，盘子移动有两种情况，1种：只有或者只剩下一个盘子的时候，只需将盘子移动到c即可；2种：盘子的数量大于1个的时候，那就需要这3根柱子相互配合，一起完成操作，最终才能将盘子移动到c柱子上面，这里只不过递归了移动这个步骤

 　　2、迭代

　　也是求阶乘，题目与上述的是一样的

　　直接上代码：

 1 #include<stdio.h>
 2 int factorial(int n) {
 3     int ret = 1;
 4     for (int i = 1; i <= n; i++)
 5     {
 6         ret *= i;
 7     }
 8     return ret;
 9 }
10 #include<stdio.h>
11 int main()
12 {
13     int num = 0;
14     printf("请打出想要输出的数的阶乘：");
15     scanf("%d", &num);
16     int ret=factorial(num);
17     printf("%d\n", ret);
18     return 0;
19 }

　　这里用到了迭代（循环）

　　斐波那契数列：

 1 #include<stdio.h>
 2 
 3 int sequence(int n) {
 4     int a = 1;
 5     int b = 1;
 6     int ret = 0;
 7     if (n>2)
 8     {
 9         for (int i = 0; i < n - 2; i++) {
10             ret = a + b;
11             a = b;
12             b = ret;
13         }
14         return ret;
15     }
16     else
17     {
18         ret = 1;
19     }
20     return ret;
21 }
22 int    main() {
23     int num = 0;
24     printf("请输入一个数字：");
25     scanf("%d", &num);
26     printf("这个数字的斐波那契值是：%d\n", sequence(num));
27     return 0;
28 }

　　交换位置，来计算数列值

总结：递归代码简单，但是效率太低

　　　迭代代码复杂，但是效率高