写一个c语言递归程序并得出结果

好的，以下是一个简单的 C 语言递归程序，用于计算斐波那契数列的第 n 项：

#include <stdio.h>

int fibonacci(int n) {
    if (n == 0) {
        return 0;
    } else if (n == 1) {
        return 1;
    } else {
        return fibonacci(n-1) + fibonacci(n-2);
    }
}

int main() {
    int n = 10;
    printf("斐波那契数列的第 %d 项为 %d\n", n, fibonacci(n));
    return 0;
}

在这个程序中，我们定义了一个名为 `fibonacci` 的递归函数，它接受一个整数参数 `n`，并返回斐波那契数列的第 `n` 项。

在 `fibonacci` 函数中，首先判断参数 `n` 是否为 0 或 1，如果是，则分别返回 0 和 1。如果不是，则递归调用 `fibonacci` 函数计算前两项的和，并返回结果。

在 `main` 函数中，我们指定要计算斐波那契数列的第 10 项，并调用 `fibonacci` 函数计算它的值。最后，将计算结果打印出来。

运行这个程序，输出结果为：

斐波那契数列的第 10 项为 55

这表明斐波那契数列的第 10 项为 55。

相关问题

用递归方法计算1到100 c语言

### 回答1：
以下是C语言递归方式计算1到100的代码：

#include <stdio.h>

int recursive_sum(int n) {
    if (n == 1) {
        return 1;
    } else {
        return n + recursive_sum(n-1);
    }
}

int main() {
    int result = recursive_sum(100);
    printf("The sum of 1 to 100 is %d", result);
    return 0;
}

在这个程序中，我们定义了一个递归函数`recursive_sum`，它接受一个整数`n`作为参数，并返回从1到`n`的和。在函数内部，我们首先检查基本情况：如果`n`等于1，那么我们已经达到了最小的可计算值，直接返回1。否则，我们递归调用`recursive_sum`函数，传入`n-1`作为参数，并将结果与`n`相加。

在`main`函数中，我们调用`recursive_sum`函数，传入100作为参数，并将结果打印到控制台上。

### 回答2：
用递归方法计算1到100的和，可以定义一个递归函数来实现。具体步骤如下：

1. 定义递归函数sum，函数参数为一个整数n。
2. 在sum函数内部，设置递归的终止条件，当n=1时，直接返回1。
3. 在sum函数内部，递归调用自身，参数为n-1，并将返回值与n相加。
4. 在主函数中调用sum函数，参数为100，得到1到100的和。

下面是C语言示例代码：

#include <stdio.h>

int sum(int n)
{
    if (n == 1) {
        return 1;
    } else {
        return n + sum(n - 1);
    }
}

int main()
{
    int result = sum(100);
    printf("1到100的和为：%d\n", result);
    return 0;
}

运行以上代码，将会输出：

1到100的和为：5050

该递归函数的原理是每次将n与n-1相加，再继续递归调用。当n减到1时，递归终止，开始回溯过程，将所有相加的结果累加返回。这样就能够得到从1到n的和。

### 回答3：
递归是一种通过函数调用自身的方法。要使用递归方法计算1到100的和，可以定义一个递归函数，该函数接受一个参数n，计算从1到n的和。然后在函数内部，首先判断n是否为1。如果是1，直接返回1作为结束条件；如果不是1，递归调用自身，传入n-1作为参数，并将递归函数的结果与n相加，最后返回计算得出的和。

以下是一个实现该递归方法的C语言代码：

#include <stdio.h>

int sum(int n) {
    if (n == 1) {
        return 1;
    } else {
        return n + sum(n - 1);
    }
}

int main() {
    int result = sum(100);
    printf("1到100的和为：%d\n", result);
    return 0;
}

在以上代码中，我们定义了一个sum函数，用来计算1到n的和。在main函数中，调用sum函数并传入100作为参数，将计算得到的结果打印输出。运行程序后，可以得到1到100的和为5050。

C语言迷宫问题，以一个m乘n的长方形方阵表示迷宫，0和1表示迷宫中的通路和障碍。现需要一个C语言程序，对任意设定的迷宫，求出一条一条从入口到出口的通路，或者得出没有通路的结论。下面是对该C语言程序的要求，首先实现一个以链表做存储结构的栈类型。然后编写一个求解迷宫的非递归程序。求得的通路用三元组（i，j，d）表示，其中i，j是迷宫中的一个坐标，d表示走到下一个坐标的方向。通常用穷举求解方法，为处理方便，可以在迷宫四周加一圈屏障。

好的，这是一个比较典型的迷宫问题，我可以帮您解决。首先，我们需要定义一个以链表做存储结构的栈类型，可以按照以下方式定义：

typedef struct Node {
    int i, j, d;
    struct Node *next;
} Node;

typedef struct {
    Node *top;
} Stack;

void InitStack(Stack *S) {
    S->top = NULL;
}

bool IsEmpty(Stack *S) {
    return S->top == NULL;
}

bool Push(Stack *S, int i, int j, int d) {
    Node *p = (Node *)malloc(sizeof(Node));
    if (p == NULL) {
        return false;
    }
    p->i = i;
    p->j = j;
    p->d = d;
    p->next = S->top;
    S->top = p;
    return true;
}

bool Pop(Stack *S, int *i, int *j, int *d) {
    if (S->top == NULL) {
        return false;
    }
    Node *p = S->top;
    *i = p->i;
    *j = p->j;
    *d = p->d;
    S->top = p->next;
    free(p);
    return true;
}

其中，Node是链表节点的结构体，包含了三元组（i，j，d），表示坐标和方向。Stack是栈的结构体，包含了一个链表节点指针top，表示栈顶。InitStack、IsEmpty、Push和Pop分别是初始化栈、判断栈是否为空、入栈和出栈的函数。

然后，我们可以编写一个非递归程序来求解迷宫。可以按照以下方式实现：

bool MazePath(int maze[MAX_ROW][MAX_COL], int m, int n) {
    Stack S;
    InitStack(&S);
    int i, j, d;
    Push(&S, 1, 1, 0);
    maze[1][1] = -1;
    while (!IsEmpty(&S)) {
        Pop(&S, &i, &j, &d);
        while (d < 4) {
            int ti = i + di[d];
            int tj = j + dj[d];
            if (ti == m && tj == n) {
                printf("(%d,%d)", i, j);
                while (!IsEmpty(&S)) {
                    Pop(&S, &i, &j, &d);
                    printf("->(%d,%d)", i, j);
                }
                printf("->(%d,%d)\n", m, n);
                return true;
            }
            if (maze[ti][tj] == 0) {
                Push(&S, i, j, ++d);
                i = ti;
                j = tj;
                d = 0;
                maze[i][j] = -1;
            } else {
                ++d;
            }
        }
    }
    printf("No path!\n");
    return false;
}

其中，di和dj是方向数组，表示往上、下、左、右四个方向移动时，i和j的变化量。在函数中，我们首先初始化栈，并将起点（1,1）入栈。然后，我们进入一个循环，每次从栈中弹出一个节点，然后按照四个方向依次尝试移动。如果移动到了终点（m,n），则输出路径，并返回true。如果移动到了通路上，则将新的节点入栈，并将当前位置标记为已经访问过（用-1表示）。如果无法移动到新的位置，则尝试下一个方向。如果栈为空，则输出“无解”并返回false。

这样，我们就可以使用上面的代码来求解任意设定的迷宫了。注意，这里的迷宫要求四周加一圈屏障。同时，MAX_ROW和MAX_COL要根据具体的迷宫大小进行定义。