如何动态生成0到n的递增两元素组合并存入二维数组？

要解决动态存储所有第一个元素小于第二个的两元素组合问题，核心是先计算组合总数、动态分配对应大小的二维数组，再修改递归逻辑把组合存入数组而非仅打印。

关键思路 #

1. 计算组合总数：n个元素的两元素组合数为 C(n,2) = n*(n-1)/2，这是二维数组的行数，每行固定存2个元素。
2. 动态内存分配：用指向指针的指针创建二维数组，先分配行的空间，再为每行分配存储两个元素的空间。
3. 递归存储组合：添加一个计数器（通过指针传递，保证递归中能持续更新），当递归到凑齐2个元素时，将数据存入数组对应位置。
4. 内存释放：使用完动态数组后，逐行释放再释放外层指针，避免内存泄漏。

修改后的完整代码 #

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

void combinationUtil(int arr[], int n, int index, int data[], int i, int** result, int* count);

// 动态生成组合并存储到二维数组，返回该数组，同时通过total参数返回组合总数
int** generateCombinations(int arr[], int n, int* total) {
    *total = n * (n - 1) / 2;
    // 分配二维数组的行空间
    int** result = malloc(*total * sizeof(int*));
    if (result == NULL) {
        perror("Failed to allocate memory for rows");
        exit(EXIT_FAILURE);
    }
    // 为每行分配2个int的空间
    for (int k = 0; k < *total; k++) {
        result[k] = malloc(2 * sizeof(int));
        if (result[k] == NULL) {
            perror("Failed to allocate memory for columns");
            // 已分配的行要提前释放
            for (int m = 0; m < k; m++) {
                free(result[m]);
            }
            free(result);
            exit(EXIT_FAILURE);
        }
    }

    int data[2];
    int count = 0;
    combinationUtil(arr, n, 0, data, 0, result, &count);
    return result;
}

void combinationUtil(int arr[], int n, int index, int data[], int i, int** result, int* count) {
    if (index == 2) {
        // 将当前组合存入二维数组
        result[*count][0] = data[0];
        result[*count][1] = data[1];
        (*count)++;
        return;
    }

    if (i >= n)
        return;

    data[index] = arr[i];
    // 选当前元素，继续递归下一个位置
    combinationUtil(arr, n, index + 1, data, i + 1, result, count);
    // 不选当前元素，递归下一个元素
    combinationUtil(arr, n, index, data, i + 1, result, count);
}

int main() {
    // 示例：动态生成0到n-1的数组，n可按需确定
    int n = 4;
    int* arr = malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) {
        arr[i] = i;
    }

    int total;
    int** combinations = generateCombinations(arr, n, &total);

    // 打印验证存储的组合
    printf("存储的组合：\n");
    for (int i = 0; i < total; i++) {
        printf("%d %d\n", combinations[i][0], combinations[i][1]);
    }

    // 释放内存
    for (int i = 0; i < total; i++) {
        free(combinations[i]);
    }
    free(combinations);
    free(arr);

    return 0;
}

代码说明 #

• generateCombinations 函数负责计算组合总数、分配内存，并调用递归函数填充数组，最终返回存储好组合的二维数组。
• 递归函数 combinationUtil 中，当凑齐2个元素时，把data里的值写入result的对应行，同时更新计数器count。
• 内存分配时做了错误检查，如果分配失败会释放已分配的内存并退出，避免内存泄漏。
• 主函数演示了动态生成输入数组的情况，符合n动态确定的需求。

运行结果 #

输入数组为0 1 2 3时，输出：

存储的组合：
0 1
0 2
0 3
1 2
1 3
2 3

内容的提问来源于stack exchange，提问作者Zandees