递归练习(C语言)

本文地址：http://www.cnblogs.com/archimedes/p/recursive-practice.html，转载请注明源地址。

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

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

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

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

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

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

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

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

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

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

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

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 < 10) 
        return n;
    else
        return ((n % 10) + DigitSum(n / 10));
}

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

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

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

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

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

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

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

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

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

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

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

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

#include<stdio.h>
void reverser(char *s, int i, int len)
{
    int c, j;
    j = len - (i + 1);
    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, 0, len);
}

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

10、二分查找

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

int *binary_search(int val, int array[], int n)
{
    int m = n / 2;
    if(n <= 0) 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 + 1, n - m - 1);
}

int main()
{
    int n;
    int *p;
    int a[6] = {1,2,3,4,5,6}; 
    while(~scanf("%d", &n)){
        p = binary_search(n, a, 6);
        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 0;
}