C语言用递归实现2*n

可以使用以下递归函数实现2*n：

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

该函数的实现思路是不断递归调用自身，直到 n 变为 0，然后返回 0。在递归返回的过程中，每次返回值都比前一次多 2。例如，当 n = 3 时，递归调用过程如下：

doubleN(3) = doubleN(2) + 2
doubleN(2) = doubleN(1) + 2
doubleN(1) = doubleN(0) + 2
doubleN(0) = 0

最终返回的结果是 2 * n = 6。

相关问题

n皇后c语言非递归实现

以下是n皇后问题的C语言非递归实现，利用栈的数据结构来实现回溯过程：

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

#define MAX_N 20

int n; // 棋盘大小
int col_count[MAX_N]; // 棋盘每一列已经放置的皇后数
int diag1_count[2 * MAX_N - 1]; // 棋盘左上角到右下角的对角线已经放置的皇后数
int diag2_count[2 * MAX_N - 1]; // 棋盘右上角到左下角的对角线已经放置的皇后数

struct queen {
    int row;
    int col;
};

struct stack {
    struct queen data[MAX_N];
    int top;
};

void push(struct stack *s, struct queen q) {
    s->data[++s->top] = q;
}

struct queen pop(struct stack *s) {
    return s->data[s->top--];
}

int is_valid(int row, int col) {
    return col_count[col] == 0 && diag1_count[row + col] == 0 && diag2_count[row - col + n - 1] == 0;
}

void print_board(struct queen *queens) {
    char board[MAX_N][MAX_N];
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            board[i][j] = '.';
        }
        board[queens[i].row][queens[i].col] = 'Q';
    }
    for (int i = 0; i < n; i++) {
        printf("%s\n", board[i]);
    }
    printf("\n");
}

void n_queen() {
    struct stack s = {{0}, -1};
    push(&s, (struct queen) {.row = 0, .col = 0});
    while (s.top >= 0) {
        struct queen q = pop(&s);
        int row = q.row, col = q.col;
        col_count[col]++;
        diag1_count[row + col]++;
        diag2_count[row - col + n - 1]++;
        if (row == n - 1) {
            struct queen queens[MAX_N];
            for (int i = 0; i < n; i++) {
                queens[i] = s.data[i];
            }
            queens[n - 1] = q;
            print_board(queens);
        } else {
            for (int next_col = 0; next_col < n; next_col++) {
                if (is_valid(row + 1, next_col)) {
                    push(&s, (struct queen) {.row = row + 1, .col = next_col});
                }
            }
        }
        col_count[col]--;
        diag1_count[row + col]--;
        diag2_count[row - col + n - 1]--;
    }
}

int main() {
    scanf("%d", &n);
    n_queen();
    return 0;
}

该算法的时间复杂度为 $O(n!)$，空间复杂度为 $O(n)$。

C语言用递归实现阶乘

以下是使用递归实现阶乘的 C 语言代码：

#include <stdio.h>

int factorial(int n) {
    if (n == 1) {
        return 1;
    } else {
        return n * factorial(n - 1);
    }
}

int main() {
    int n, result;
    printf("请输入一个正整数：");
    scanf("%d", &n);
    result = factorial(n);
    printf("%d的阶乘是：%d\n", n, result);
    return 0;
}

在上面的代码中，factorial() 是递归函数。当参数 n 等于 1 时，函数返回 1。否则，函数调用自身并返回 n * factorial(n - 1)。在 main() 函数中，用户输入一个正整数 n，然后调用 factorial() 函数计算 n 的阶乘并输出结果。