在看到辗转相除法的递归解法后，不禁想到涉及比较的分治算法、三目运算符和递归简直就是绝配，一眨眼，脑海中就迸出了数列最小值的递归解法，每一个数都与后面数组的最小值相比较，思路有了，动手吧。

1. //辗转相除法   
2. int gcd_division(int a,int b)  
3. {  
4.     return b==0?a:gcd_division(b,a%b);   
5. }  

    

一、思路与改进

    将数组每一个元素与该元素后数组最小值相比较，最后一个数组元素返回自身，即可得到整个数组的最小值。图示如下：

转化成代码就是这样一个函数：

1. //arr[]:数组  len:数组长度    n:当前下标   
2. int f(int arr[],int len,int n)  
3. {  
4.     if(n == len-1)  
5.         return arr[n];  
6.         
7.     return arr[n]<f(arr,len,n+1)?arr[n]:f(arr,len,n+1);  
8. }  

   跑一遍：

没问题，不过这递归把f(arr,len,n+1)算了两遍，效率太低了，得改。先求结果，再把结果放入return里。代码如下：

1. //arr[]:数组  len:数组长度    n:当前下标   
2. int f(int arr[],int len,int n)  
3. {  
4.     if(n == len-1)  
5.         return arr[n];  
6.         
7.     int min = f(arr,len,n+1);  
8.     return arr[n]<min?arr[n]:min;  
9. }  

   ok，效率提升了，不过这样的话，三目运算符就只剩下一个比较的操作了，可以再精简一下，定义一个比较元素的宏：MIN(X,Y)

10. #define MIN(X,Y) ((X<Y)?(X):(Y))  

改一下return里的语句：

1. //arr[]:数组  len:数组长度    n:当前下标   
2. int f(int arr[],int len,int n)  
3. {  
4.     if(n == len-1)  
5.         return arr[n];  
6.         
7.     int min = f(arr,len,n+1);  
8.     return MIN(min,arr[n]);  
9. }  

   搞定~

源代码：

1. #include <stdio.h>  
2. #define N 10  
3. #define MIN(X,Y) ((X<Y)?(X):(Y))  
4.     
5. int f(int arr[],int len,int n)  
6. {  
7.     if(n == len-1)  
8.         return arr[n];  
9.         
10.     int min = f(arr,len,n+1);  
11.     
12.     return MIN(min,arr[n]);  
13. }  
14.     
15. int main (void)  
16. {  
17.     int arr[N] = {2,4,1,3,5,6,7,8,-11};  
18.         
19.     int min = f(arr,N,0);  
20.     printf("%d ",min);  
21.         
22.     return 0;  
23. }