如何封装矩阵循环为函数？用1D数组实现方阵对角线下方求和

针对你的需求，我们可以直接用1D数组模拟方阵，通过index = row * N + col的映射关系完成所有操作，完全不需要先构建2D数组再转换。下面是拆解后的实现方案：

核心思路 #

方阵的每个元素array[row][col]可以直接对应到1D数组的line[row * N + col]（N为方阵边长），所有对2D数组的操作都可以通过这个映射在1D数组上完成，既满足禁止传递2D数组的要求，又简化了逻辑。

分步实现 #

1. 封装输入方阵大小的函数 #

确保用户输入的是方阵（行和列相等），避免后续逻辑出错：

void get_square_size(int *n) {
    int rows, cols;
    printf("请输入方阵的行数：");
    scanf("%d", &rows);
    printf("请输入方阵的列数：");
    scanf("%d", &cols);
    while (rows != cols) {
        printf("错误！方阵的行和列必须相等，请重新输入：\n");
        printf("行数：");
        scanf("%d", &rows);
        printf("列数：");
        scanf("%d", &cols);
    }
    *n = rows;
}

2. 封装生成随机1D方阵的函数 #

动态分配内存（避免栈溢出），并填充指定范围的随机数：

int* generate_square_array(int n, int lbound, int ubound) {
    int* arr = (int*)malloc(n * n * sizeof(int));
    if (!arr) {
        printf("内存分配失败！");
        exit(1);
    }
    for (int row = 0; row < n; row++) {
        for (int col = 0; col < n; col++) {
            int index = row * n + col;
            arr[index] = mrand48() % (ubound - lbound + 1) + lbound;
        }
    }
    return arr;
}

3. 封装计算主对角线下方元素和的函数 #

遍历1D数组，通过映射关系判断元素是否在主对角线下方（row > col），并求和：

int calculate_below_diagonal_sum(int* arr, int n) {
    int sum = 0;
    for (int row = 0; row < n; row++) {
        for (int col = 0; col < n; col++) {
            if (row > col) {
                int index = row * n + col;
                sum += arr[index];
            }
        }
    }
    return sum;
}

4. 辅助函数：打印1D方阵（可选，用于验证） #

把1D数组按方阵格式打印，方便查看：

void print_square_array(int* arr, int n) {
    printf("方阵内容：\n");
    for (int row = 0; row < n; row++) {
        for (int col = 0; col < n; col++) {
            int index = row * n + col;
            printf("%d ", arr[index]);
        }
        printf("\n");
    }
}

完整代码 #

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

#define LBOUND -10
#define UBOUND 10

void get_square_size(int *n);
int* generate_square_array(int n, int lbound, int ubound);
int calculate_below_diagonal_sum(int* arr, int n);
void print_square_array(int* arr, int n);

int main() {
    int n;
    get_square_size(&n);
    
    srand48(time(NULL)); // 初始化随机数生成器
    int* square_arr = generate_square_array(n, LBOUND, UBOUND);
    
    print_square_array(square_arr, n);
    
    int sum = calculate_below_diagonal_sum(square_arr, n);
    printf("主对角线下方元素的和：%d\n", sum);
    
    // 打印1D数组原始内容（可选）
    printf("1D数组原始内容：");
    for (int i = 0; i < n*n; i++) {
        printf("%d ", square_arr[i]);
    }
    printf("\n");
    
    free(square_arr); // 释放动态分配的内存
    return 0;
}

void get_square_size(int *n) {
    int rows, cols;
    printf("请输入方阵的行数：");
    scanf("%d", &rows);
    printf("请输入方阵的列数：");
    scanf("%d", &cols);
    while (rows != cols) {
        printf("错误！方阵的行和列必须相等，请重新输入：\n");
        printf("行数：");
        scanf("%d", &rows);
        printf("列数：");
        scanf("%d", &cols);
    }
    *n = rows;
}

int* generate_square_array(int n, int lbound, int ubound) {
    int* arr = (int*)malloc(n * n * sizeof(int));
    if (!arr) {
        printf("内存分配失败！");
        exit(1);
    }
    for (int row = 0; row < n; row++) {
        for (int col = 0; col < n; col++) {
            int index = row * n + col;
            arr[index] = mrand48() % (ubound - lbound + 1) + lbound;
        }
    }
    return arr;
}

int calculate_below_diagonal_sum(int* arr, int n) {
    int sum = 0;
    for (int row = 0; row < n; row++) {
        for (int col = 0; col < n; col++) {
            if (row > col) {
                int index = row * n + col;
                sum += arr[index];
            }
        }
    }
    return sum;
}

void print_square_array(int* arr, int n) {
    printf("方阵内容：\n");
    for (int row = 0; row < n; row++) {
        for (int col = 0; col < n; col++) {
            int index = row * n + col;
            printf("%d ", arr[index]);
        }
        printf("\n");
    }
}

关键修正说明 #

• 修正了原代码中随机数生成的参数顺序错误，避免逻辑异常
• 使用动态内存分配malloc替代变长数组（VLA），提升代码兼容性和安全性
• 完全抛弃2D数组，所有操作直接在1D数组上完成，满足禁止传递2D数组的要求
• 增加输入校验，确保用户输入的是合法方阵

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