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

一：函数

　　1、递归

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

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

复制代码

　　这里就是：运用了阶乘运算的思想，
　　1！=1*1
　　2！=2*1！
　　3！=3*2！
　　4！=4*3！
　　·······
　　n！=n*（n-1）！
　　以是这里就是运用这个想法来将运行的步骤进行大略，从而使代码变成2行
 
　　斐波那契数列：

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

复制代码

 
 
　　这里还有一个非常经典的递归题目：汉诺塔
　　从左到右有A、B、C三根柱子，其中A柱子上面有从小叠到大的n个圆盘，现要求将A柱子上的圆盘移到C柱子上去，期间只有一个原则：一次只能移到一个盘子且大盘子不能在小盘子上面，求移动的步骤和移动的次数
　　先上代码，然后表明

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

复制代码

　　互换位置，来计算数列值
 
总结：递归代码简单，但是效率太低
　　　迭代代码复杂，但是效率高
 

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。