C语言——递归练习

1、炮弹一样的球状物体，能够堆积成一个金字塔，在顶端有一个炮弹，它坐落在一个4个炮弹组成的层面上，而这4个炮弹又坐落在一个9个炮弹组成的层面上，以此类推。写一个递归函数CannonBall，这个函数把金字塔的高度作为参数，并且返回它所包括的炮弹数量。函数必须按照递归方式实现，不可以使用迭代结构，例如while或for。

#include<stdio.h>
int CannonBall(int h)
{
    if(h == ) return ;
    else
        return CannonBall(h-) + pow(h,);
}
int main(void)
{
    printf("%d\n",CannonBall());
    return ;
}

2、使用C编写一个指数函数，实现n^k

#include<stdio.h>
int RaiseToPower(int n, int k)
{
    if(k == )
        return ;
    else
        return n * RaiseToPower(n,k -);
}

int main()
{
    printf("%d\n",RaiseToPower(,));
    return ;
}

3、使用欧几里得公式写一个递归函数gcd（m,n)，用来计算m与n的最大公约数.

#include<stdio.h>
int gcd(int m, int n)
{
    if(m % n ==)
        return n;
    else
        return gcd(n,m % n);
}

int main()
{
    printf("%d\n",gcd(,));
    return ;
}

4、写一个递归函数DigitSum(n)，输入一个非负整数，返回组成它的数字之和，例如，调用DigitSum(1729)，则应该返回1+7+2+9，它的和是19

#include<stdio.h>
int DigitSum(int n)
{
    if(n < )
        return n;
    else
        return ((n % ) + DigitSum(n / ));
}

int main()
{
    printf("%d\n",DigitSum());
    return ;
}

5、整数n的数字根是如下定义的：它是一个整数的所有数字的和，反复相加，直到只剩下一位数字为止。例如：1729的digital root按照如下的步骤计算：

step 1:    1+7+2+9   ----->  19

step 2:    1+9       ----->  10

step 3:    1+0       ----->  1

因为第三步的结果是1，所以1就是数字根的值。

写一个函数DigitalRoot（n），返回参数的根，注意：写一个纯粹的、不使用任何循环结构的递归函数。

#include<stdio.h>
int DigitSum(int n)
{
    if(n < )
        return n;
    else
        return ((n % ) + DigitSum(n / ));
}

int DigitalRoot(int n)
{
    if(n < )
        return n;
    else
        return DigitalRoot(DigitSum(n));
}

int main()
{
    printf("%d\n",DigitalRoot());
    return ;
}

6、计算组合数C（n，k）

#include<stdio.h>
int Comb(int n, int k)
{
    if(k ==  || n == k)
        return ;
    else
        return (Comb(n - ,k - ) + Comb(n - ,k));
}

int main()
{
    int i;
    for(i = ; i <= ; i++)
    {
        printf("%d ",Comb(,i));
    }
    printf("\n");
    return ;
}

7、将一个整数作为字符串打印

#include<stdio.h>
void printd(int n)
{
    if(n < ) {
        putchar('-');
        n = -n;
    }
    if(n / )
        printd(n / );
    putchar(n %  + '');
}

int main()
{
    int a = ;
    printd(a);
    printf("\n");
    return ;
}

8、运用上面printd函数的设计思想编写一个递归版本的itoa函数，即通过递归函数把整数变为字符串

#include<stdio.h>
void itoa(int n, char *s)
{
    static int i;
    if(n / )
        itoa(n / , s);
    else {
        i = ;
        if(n < )
            s[i++] = '-';
    }
    s[i++] = abs(n) %  + '';
    s[i] = '\0';
}

int main()
{
    char s[];
    int n = ;
    itoa(n, s);
    printf("%s\n",s);
    return ;
}

9、编写一个递归版本的reverse（s）函数，以将字符串s转置

#include<stdio.h>
void reverser(char *s, int i, int len)
{
    int c, j;
    j = len - (i + );
    if(i < j) {
        c = s[i];
        s[i] = s[j];
        s[j] = c;
        reverser(s, ++i, len);
    }
}

void reverse(char *s)
{
    int len;
    len = strlen(s);
    reverser(s, , len);
}

int main()
{
    char s[];
    gets(s);
    reverse(s);
    printf("%s\n",s);
    return ;
}

10、二分查找

#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>

int *binary_search(int val, int array[], int n)
{
    int m = n / ;
    if(n <= ) return NULL;
    if(val == array[m]) return array + m;
    if(val < array[m]) return binary_search(val, array, m);
    else return binary_search(val, array + m + , n - m - );
}

int main()
{
    int n;
    int *p;
    int a[] = {,,,,,};
    while(~scanf("%d", &n)){
        p = binary_search(n, a, );
        if(p) {
            printf("this number is in the array at position %d\n", p - a);
        } else {
            printf("this number is not in the array\n");
        }
    }
    return ;
}   

http://www.cnblogs.com/archimedes/p/recursive-practice.html