一些基本算法的递归实现

问题描述：

递归是计算机科学中最伟大的思想。按照我的理解，所谓递归就是把问题化约为比自身维度更小的问题，直至边界点（base condition)，

然后利用边界点的解的结果（相对容易得到）和一定规则回退得到最终所需要的结果。

        常用到的递归思想的可归类为：

1. 各种tree construct 的操作：遍历（inorder, preorder, postorder)，深度优先搜索（dfs)，广度优先搜索（bfs)，插入，删除，返回最值等；

        2. 各种搜索问题最终都能化约为递归问题。比如八皇后，排列，组合，背包等等；

3. 下面我尝试用递归思想实现一些平时最常用的操作（比如加法，乘法等）：

代码如下：

[cpp]  view plain copy

1. int max( int a, int  b )  
2. {  
3.     if( a  > b )  
4.         return a;  
5.       
6.     return b;  
7. }  
8.   
9. int min( int a, int b )  
10. {  
11.     if( a < b )  
12.         return a;  
13.       
14.     return b;  
15. }  
16.   
17. int Add( int m, int n )  
18. {  
19.     if( 0 == n )  
20.         return 0;  
21.       
22.     return Add( m + 1, n - 1);  
23. }  
24.   
25. int Mutiple( int m, int n )  
26. {  
27.     if( 1 == n )  
28.     {  
29.         return m;  
30.     }  
31.       
32.     return Mutiple( m + m, n - 1 )  
33. }  
34.   
35. int Subtract( int m, int n )  
36. {  
37.     if( 0 == n )  
38.     {  
39.         return 0;  
40.     }  
41.       
42.     return Subtract( m - 1, n - 1 );  
43. }  
44.   
45. int findMax( int* items, int idx, int size )  
46. {  
47.     if( idx == size - 1)  
48.         return items[idx];  
49.       
50.     return max(  findMax( items, idx + 1, size ), items[idx] );  
51. }  
52.   
53. int findMin( int* items, int idx, int size )  
54. {  
55.     if( idx == size - 1 )  
56.         return items[idx];  
57.       
58.     return min( findMin( items, idx + 1, size ), items[idx] );  
59. }  
60.   
61. int Search( int* items, int idx, int size, int val )  
62. {  
63.     if( idx >= size )  
64.         return -1;  
65.       
66.     if( items[idx] == val )  
67.         return idx;  
68.       
69.     return Search( items, idx + 1, size, val );  
70. }  
71.   
72. int BinarySearch( int* items, int begin, int end, int val )  
73. {  
74.     if( begin > end )  
75.         return -1;  
76.       
77.     int mid = begin + ( ( end - begin ) >> 1 );  
78.     if( items[mid] > val )  
79.     {  
80.         return BinarySearch( items, begin, mid - 1, val );  
81.     }  
82.     else if( items[mi] < val )  
83.     {  
84.         return BinarySearch( items, mid + 1, end, val );  
85.     }  
86.     else  
87.     {  
88.         return mid;  
89.     }  
90. }  
91.   
92. int gcd( int n, int m )  
93. {  
94.     if( 0 == m )  
95.         return n;  
96.       
97.     return gcd( m, n % m );  
98. }  
99.   
100. int fibonical( int n )  
101. {  
102.     if( 1  == n )  
103.         return 1;  
104.       
105.     return fibonical( n - 1 ) + fibonical( n - 2 );  
106. }  
107.   
108. int fictional( int n )  
109. {  
110.     if( 1 == n )  
111.         return n;  
112.       
113.     return n * fictional( n - 1 );  
114. }  
115.   
116. unsigned int power( int n, int m )  
117. {  
118.     if( 1 == m )  
119.         return n;  
120.       
121.     return power( n * m, m - 1 );  
122. }  
123.   
124.   
125. unsigned int powerQuick( int n, int m )  
126. {  
127.     if( 1 == m )  
128.         return n;  
129.       
130.     unsigned int k = powerQuick( n, m / 2 );  
131.       
132.     if( 0 == m % 2 )  
133.     {  
134.         return k * k;  
135.     }  
136.     else  
137.     {  
138.         return k * k * powerQuick( n, 1 );  
139.     }  
140.       
141. }  
142.   
143.   
144.   
145. unsigned int Fib( int n, unsigned int a, unsigned int b )  
146. {  
147.     if( 1 == n )  
148.         return b;  
149.       
150.     return Fib( n - 1, b, a + b );  
151. }  
152.   
153.   
154. void EulerLetter( int n, int depth, int* result )  
155. {  
156.     if( depth == n )  
157.     {  
158.         for( int i = 0; i < dpeth; i++ )  
159.         {  
160.             printf( "%d ", result[i] );  
161.         }  
162.           
163.         printf( "\n" );  
164.       
165.         return;  
166.     }  
167.       
168.       
169.     for( int i = 0; i < n; i++ )  
170.     {  
171.         if( depth != i )  
172.         {  
173.             result[depth] = i;  
174.             EulerLetter( n, depth + 1, result );  
175.         }  
176.     }  
177. }