分治思想：    
 斐波那契数列的迭代实现：（兔子繁殖问题）

1. #include <stdio.h>
3. int main()
4. {
5.     int i;
6.     int a[40];
8.     a[0] = 0;
9.     a[1] = 1;
11.     for(i = 2; i < 40; i++)
12.     {
13.         a[i] = a[i - 1] + a[i - 2];
14.         printf("%d", a[i]);
15.     }
16.     return 0;
17. }

    
斐波那契数列的递归实现：（兔子繁殖问题）  

1. int Fib(int i)
2. {
3.     if(i < 2)
4.         return i == 0 ? 0 : 1;
5.     return Fib(i - 1) + Fib(i - 2);
6. }

    
对比以上两个代码发现

1. 迭代和递归的区别是：迭代使用的是循环结构，递归使用的是选择结构
   
2. 使用递归使程序的结构更清晰，更简洁，更容易让人理解，从而减少读懂代码的时间
3. 大量的递归调用会减少函数的副本，会消耗大量的时间和内存，而迭代则不需要此种付出
4. 递归函数分为调用和回退阶段，递归的回退顺序是它调用顺序的逆序

      
折半查找算法的递归实现：

    
    折半查找法是一种常用的查找方法，该方法通过不断缩小一半查找的范围，知道达到目的。

    
汉诺塔问题实现：

1. //将 n 个盘子从 x 借助 y 移动到 z
2. void move(int n, char x, char y, char z)
3. {
4.     if(1 == n)
5.     {
6.         printf("%c --> %c\n", x, z);
7.     }
8.     else
9.     {
10.         move(n - 1, x, z, y); //将 n - 1 个盘子从 x 借助 z 移动到 y 上
11.         printf("%c --> %c\n", x, z); //将第 n 个盘子从 x 移动到 z 上
12.         move(n - 1, y, x, z); //将 n - 1 个盘子从 y 借助 x 移动到 z 上
13.     }
14. }
16. int main()
17. {
18.     int n;
19.     printf("请输入层数: ");
20.     scanf("%d", &n);
21.     move(n, 'X','Y', 'Z');
22.     return 0;
23. }

 
    八皇后问题：     
    在 8 X 8 格的国际象棋上摆放八个皇后，使其不能互相攻击，即任意两个皇后都不能处于同一行，同一列或同一斜线上，共用多少种摆法？  

1. #include <stdio.h>
3. int count = 0;
5. int notdanger(int row, int j, int (*chess)[8])
6. {
7.     int i, flag1, flag2, flag3, flag4, flag5;
9.     //判断列方向
10.     for(i = 0; i < 8; i++)
11.     {
12.         if(*(*(chess + i) + j) != 0)
13.         {
14.         flag1 = 1;
15.          break;
16.         }
17.     }
19.     //判断左上方
20.     for(i = row, k = j; i < 8 && k < 8; i++, k++)
21.     {
22.         if(*(*(chess + i) + k) != 0)
23.         {
24.             flag2 = 1;
25.             break;
26.         }
27.     }
29.     //判断右下方
30.     for( i = row, k = j; i < 8 && k < 8; i ++, k ++)
31.     {
32.         if(*(*(chess + i) + k ) != 0)
33.         {
34.             flag3 = 1;
35.             break;
36.         }
37.     }
39.     //判断右上方
40.     for( i = row, k = j; i >= 0 && k < 8; i--, k++)
41.     {
42.         if(*(*(chess + i) + k) != 0)
43.         {
44.             flag4 = 1;
45.             break;
46.         }
47.     }
49.     //判断左下方
50.     for( i = row, k = j; i < 8 && k >= 0; i++, k--)
51.     {
52.         if(*(*(chess + i) + k) != 0)
53.         {
54.             flag5 = 1;
55.             break;
56.         }
57.     }
59.     if( flag1 || flag2 || flag3 || flag4 || flag5)
60.     {
61.         return 0;
62.     }
63.     else
64.     {
65.         return 1;
66.     }
67. }
69. //参数row ：表示起始行
70. //参数n ：表示列数
71. //参数（*chess）[8] : 表示指向棋盘每一行的指针
72. void EightQueen(int row, int n, int (*chess)[8])
73. {
74.     int chess2[8][8], i, j;
75.     for(i = 0; i < 8; i++)
76.     {
77.         for(j = 0; j < 8; j++)
78.         {
79.         chess2[i][j] = chess[i][j];
80.         }
81.     }
83.     if(8 == row)
84.     {
85.         printf("第 %d 种"， count + 1);
86.         for(i = 0; i < 8; i++)
87.         {
88.             for(j = 0; j < 8; j++)
89.             {
90.                 printf("%d", *(*(chess2 + i) +j));
91.             }
92.             printf("\n");
93.         }
94.         printf("\n");
95.         count++;
96.     }
97.     else
98.     {
99.         for(j = 0; j < n; j++)
100.         {
101.          if( notdanger(row, j, chess) ) //判断是否危险
102.          {
103.                 for( i = 0; i < 8; i++)
104.                 {
105.                     *(*(chess2 + row) + i) = 0;
106.                 }
108.                 *(*(chess2 + row) + i) = 1;
110.                 EightQueen(row + 1, n, chess2);
111.          }
112.         }
113.     }
114. }
116. int main()
117. {
118.     int chess[8][8], i, j;
119.     for(i = 0; i < 8; i++)
120.     {
121.         for(j = 0; j < 8 ; j++)
122.         {
123.         chess[i][j] = 0;
124.         }    
125.     }
126.     EightQueen(0, 8, chess);
127.     printf(“总共有 %d 种解决方法！\n”, count);
128.     return 0;
129. }