C语言二维数组定义、赋值、按要求遍历操作、输出以及函数调用

于 2024-07-13 15:04:36 发布
阅读量1.3k 收藏 14
点赞数 16
文章标签： c语言 算法 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_67484548/article/details/140399701
版权

二维数组的定义

        静态定义

                语法：数据类型 数组名[行数][列数];

                举个栗子：

int matrix[3][4];

                特点：在编译时分配内存，行数和列数必须是常量表达式。

        动态定义

                语法：使用指针的指针（例如，int**matrix;）结合malloc或calloc函数。

                举个栗子：

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

int main() {
    int rows = 3;       // 定义行数
    int cols = 4;       // 定义列数
    int **matrix;       // 声明一个指向指针的指针

    // 动态分配行指针数组
    matrix = (int **)malloc(rows * sizeof(int *));
    if (matrix == NULL) {
        fprintf(stderr, "Memory allocation failed!\n");
        return 1;
    }

    // 动态分配每一行的内存
    for (int i = 0; i < rows; ++i) {
        matrix[i] = (int *)malloc(cols * sizeof(int));
        if (matrix[i] == NULL) {
            fprintf(stderr, "Memory allocation failed for row %d!\n", i);
            // 释放之前分配的内存
            for (int j = 0; j < i; ++j) {
                free(matrix[j]);
            }
            free(matrix);
            return 1;
        }
    }

    // 赋值
    for (int i = 0; i < rows; ++i) {
        for (int j = 0; j < cols; ++j) {
            matrix[i][j] = i * cols + j + 1; // 示例赋值
        }
    }

    // 打印二维数组
    for (int i = 0; i < rows; ++i) {
        for (int j = 0; j < cols; ++j) {
            printf("%d ", matrix[i][j]);
        }
        printf("\n");
    }

    // 释放内存
    for (int i = 0; i < rows; ++i) {
        free(matrix[i]); // 释放每一行的内存
    }
    free(matrix); // 释放行指针数组的内存

    return 0;
}

                特点：在运行时分配内存，适用于行数或列数不确定的情况。

二维数组的属性

        行数和列数

                行数：数组的第一个维度，表示数组有多少行。

                列数：数组的第二个维度，表示数组有多少列。

        元素类型

                可以是任何基本数据类型（如int、float、char等）或复合数据类型（如结构体）。

二维数组的初始化

        静态初始化

                在数组定义时直接赋值。

        举个栗子

int matrix[2][3]={{1,2,3},{4,5,6}};

        动态初始化

                通过循环或其他逻辑在运行时赋值。

        举个栗子

for(int i=0; i<rows; ++i) { // 开始一个循环，循环变量i从0开始，直到小于rows（行数），每次循环i递增1。
    // 这个外层循环用于遍历每一行

    for(int j=0; j<cols; ++j) { // 在内层开始另一个循环，循环变量j从0开始，直到小于cols（列数），每次循环j递增1。
        // 这个内层循环用于遍历当前行的每一列

        matrix[i][j] = i*cols + j; // 将当前行的当前列的元素设置为i*cols + j，这里是一个简单的计算，将行索引与列索引结合来赋值
        // 实际上，这行代码为二维数组赋值，创建了一个递增的序列

    } // 内层循环结束
    // 完成当前行的所有列的赋值

} // 外层循环结束
// 完成所有行的赋值

二维数组的访问

        访问单个元素

                使用行索引和列索引访问。

        举个栗子   

#include <stdio.h>

int main() {
    int rows = 3;       // 定义二维数组的行数
    int cols = 4;       // 定义二维数组的列数
    int matrix[3][4] = { // 静态初始化二维数组
        {1, 2, 3, 4},   // 第0行
        {5, 6, 7, 8},   // 第1行
        {9, 10, 11, 12} // 第2行
    };

    // 定义要访问的元素的行索引和列索引
    int targetRow = 1; // 我们想要访问第1行（注意：索引从0开始）
    int targetCol = 2; // 我们想要访问第1行的第3列（索引从0开始）

    // 访问并打印指定位置的元素
    printf("Element at matrix[%d][%d] is: %d\n", targetRow, targetCol, matrix[targetRow][targetCol]);

    return 0;
}

        遍历整个数组

                使用嵌套循环，外层循环控制行，内层循环控制列。

                举个栗子

                创建一个3行4列的二维数组，并为其每个元素赋值。

for(int i=0; i<rows; ++i) { // 开始一个循环，循环变量i从0开始，直到小于rows（行数），每次循环i递增1。
    // 这个外层循环用于遍历二维数组的每一行

    for(int j=0; j<cols; ++j) { // 在内层开始另一个循环，循环变量j从0开始，直到小于cols（列数），每次循环j递增1。
        // 这个内层循环用于遍历当前行的每一列

        // 访问或操作matrix[i][j] // 这里是一个占位符，表示在这个位置可以进行对matrix[i][j]的访问或操作。
        // 例如，可以打印matrix[i][j]的值，或者对它进行赋值，或者进行其他操作。

    } // 内层循环结束
    // 完成当前行的所有列的访问或操作

} // 外层循环结束
// 完成所有行的访问或操作

二维数组的操作

        赋值

                为数组元素赋予新的值，可以是直接赋值或通过计算。

                举个栗子

                创建一个3行4列的二维数组，并为其每个元素赋值。

#include <stdio.h>

int main() {
    int rows = 3;       // 定义二维数组的行数
    int cols = 4;       // 定义二维数组的列数
    int matrix[3][4];    // 定义一个3行4列的二维数组

    // 为二维数组的每个元素赋值
    for(int i=0; i<rows; ++i) { // 外层循环遍历行
        for(int j=0; j<cols; ++j) { // 内层循环遍历列
            // 赋值操作
            matrix[i][j] = i * cols + j; // 赋值逻辑，这里只是示例，可以根据需要修改
        }
    }

    // 打印二维数组以验证赋值是否成功
    for(int i=0; i<rows; ++i) {
        for(int j=0; j<cols; ++j) {
            printf("%d ", matrix[i][j]); // 打印矩阵元素
        }
        printf("\n"); // 每行结束后换行
    }

    return 0;
}

        遍历

                按照行优先或列优先的顺序访问数组元素。

                举个栗子

                创建一个3行4列的二维数组，并遍历其每个元素，打印出它们的值。

#include <stdio.h>

int main() {
    int rows = 3;       // 定义二维数组的行数
    int cols = 4;       // 定义二维数组的列数
    int matrix[3][4];    // 定义一个3行4列的二维数组

    // 初始化二维数组（这里只是打印出初始值，没有实际赋值）
    for(int i=0; i<rows; ++i) { // 外层循环遍历行
        for(int j=0; j<cols; ++j) { // 内层循环遍历列
            printf("%d ", matrix[i][j]); // 打印矩阵元素
        }
        printf("\n"); // 每行结束后换行
    }

    return 0;
}

        输出

                使用 printf 函数将数组内容打印到控制台。

                举个栗子

                创建一个3行4列的二维数组，并遍历其每个元素，打印出它们的值。

#include <stdio.h>

int main() {
    int rows = 3;       // 定义二维数组的行数
    int cols = 4;       // 定义二维数组的列数
    int matrix[3][4];    // 定义一个3行4列的二维数组

    // 初始化二维数组
    for(int i=0; i<rows; ++i) { // 外层循环遍历行
        for(int j=0; j<cols; ++j) { // 内层循环遍历列
            matrix[i][j] = i * cols + j; // 赋值逻辑，这里只是示例，可以根据需要修改
        }
    }

    // 打印二维数组以验证赋值是否成功
    for(int i=0; i<rows; ++i) {
        for(int j=0; j<cols; ++j) {
            printf("%d ", matrix[i][j]); // 打印矩阵元素
        }
        printf("\n"); // 每行结束后换行
    }

    return 0;
}

        转置

                交换数组的行和列，适用于矩阵操作。

                需要创建一个新的数组来存储转置后的结果。

                举个栗子

                如何将一个3行4列的二维数组转置。

#include <stdio.h>

// 函数声明
void transposeMatrix(int **matrix, int **transposed, int rows, int cols);

int main() {
    int rows = 3;       // 定义二维数组的行数
    int cols = 4;       // 定义二维数组的列数
    int matrix[3][4];    // 定义一个3行4列的二维数组
    int transposed[4][3]; // 转置后的二维数组，需要提前声明

    // 初始化二维数组
    for(int i=0; i<rows; ++i) { // 外层循环遍历行
        for(int j=0; j<cols; ++j) { // 内层循环遍历列
            matrix[i][j] = i * cols + j; // 赋值逻辑，这里只是示例，可以根据需要修改
        }
    }

    // 转置二维数组
    transposeMatrix(matrix, transposed, rows, cols);

    // 打印原始二维数组
    printf("原始二维数组：\n");
    for(int i=0; i<rows; ++i) {
        for(int j=0; j<cols; ++j) {
            printf("%d ", matrix[i][j]);
        }
        printf("\n");
    }

    // 打印转置后的二维数组
    printf("转置后的二维数组：\n");
    for(int i=0; i<cols; ++i) {
        for(int j=0; j<rows; ++j) {
            printf("%d ", transposed[i][j]);
        }
        printf("\n");
    }

    return 0;
}

// 函数定义
void transposeMatrix(int **matrix, int **transposed, int rows, int cols) {
    for(int i=0; i<rows; ++i) {
        for(int j=0; j<cols; ++j) {
            transposed[j][i] = matrix[i][j]; // 交换行和列
        }
    }
}

二维数组的内存管理

        静态分配

                内存分配在栈上，程序结束时自动释放。

                静态分配是指在编译时就已经知道数组的大小，因此可以在栈上分配内存。

                这种方法适用于数组大小固定且在程序执行过程中不需要改变的情况。

                举个栗子

                        在这个例子中，我们定义了一个3行4列的二维数组matrix，并在栈上分配了内存。

                        数组的大小在编译时就已经确定，因此不需要在运行时进行内存分配或释放。

#include <stdio.h>

int main() {
    int rows = 3;       // 定义二维数组的行数
    int cols = 4;       // 定义二维数组的列数
    int matrix[3][4];    // 静态分配二维数组

    // 初始化二维数组
    for(int i=0; i<rows; ++i) { // 外层循环遍历行
        for(int j=0; j<cols; ++j) { // 内层循环遍历列
            matrix[i][j] = i * cols + j; // 赋值逻辑，这里只是示例，可以根据需要修改
        }
    }

    // 打印二维数组以验证赋值是否成功
    for(int i=0; i<rows; ++i) {
        for(int j=0; j<cols; ++j) {
            printf("%d ", matrix[i][j]); // 打印矩阵元素
        }
        printf("\n"); // 每行结束后换行
    }

    return 0;
}

        动态分配

                使用malloc或calloc在堆上分配内存。

                需要手动释放内存，以避免内存泄漏。

                动态分配是指在运行时使用malloc或calloc函数在堆上分配内存。

                这种方法适用于数组大小在运行时才确定的情况，或者需要频繁更改数组大小的情况。

                举个栗子

                        在这个例子中，我们首先声明了一个指向指针的指针matrix。

         然后在运行时使用malloc为行指针数组分配内存。               

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

int main() {
    int rows = 3;       // 定义二维数组的行数
    int cols = 4;       // 定义二维数组的列数
    int **matrix;       // 声明一个指向指针的指针

    // 动态分配行指针数组
    matrix = (int **)malloc(rows * sizeof(int *));
    if (matrix == NULL) {
        fprintf(stderr, "Memory allocation failed!\n");
        return 1;
    }

    // 动态分配每一行的内存
    for (int i = 0; i < rows; ++i) {
        matrix[i] = (int *)malloc(cols * sizeof(int));
        if (matrix[i] == NULL) {
            fprintf(stderr, "Memory allocation failed for row %d!\n", i);
            // 释放之前分配的内存
            for (int j = 0; j < i; ++j) {
                free(matrix[j]);
            }
            free(matrix);
            return 1;
        }
    }

    // 初始化二维数组
    for(int i=0; i<rows; ++i) { // 外层循环遍历行
        for(int j=0; j<cols; ++j) { // 内层循环遍历列
            matrix[i][j] = i * cols + j; // 赋值逻辑，这里只是示例，可以根据需要修改
        }
    }

    // 打印二维数组以验证赋值是否成功
    for(int i=0; i<rows; ++i) {
        for(int j=0; j<cols; ++j) {
            printf("%d ", matrix[i][j]); // 打印矩阵元素
        }
        printf("\n"); // 每行结束后换行
    }

    // 释放内存
    for (int i = 0; i < rows; ++i) {
        free(matrix[i]); // 释放每一行的内存
    }
    free(matrix); // 释放行指针数组的内存

    return 0;
}

二维数组与函数

        作为参数传递

                传递数组时，必须指定除第一维外的所有维度。

        举个栗子

                当二维数组作为函数的参数传递时，必须指定除第一维外的所有维度。

                这意味着我们需要告诉函数数组的行数和列数。

                在这个例子中，printMatrix函数接受一个二维数组matrix

                以及它的行数rows和列数cols。通过这些参数，函数知道如何遍历和打印数组。

#include <stdio.h>

// 函数声明
void printMatrix(int rows, int cols, int matrix[rows][cols]);

int main() {
    int rows = 3;       // 定义二维数组的行数
    int cols = 4;       // 定义二维数组的列数
    int matrix[3][4];    // 定义一个3行4列的二维数组

    // 初始化二维数组
    for(int i=0; i<rows; ++i) { // 外层循环遍历行
        for(int j=0; j<cols; ++j) { // 内层循环遍历列
            matrix[i][j] = i * cols + j; // 赋值逻辑，这里只是示例，可以根据需要修改
        }
    }

    // 调用函数打印二维数组
    printMatrix(rows, cols, matrix);

    return 0;
}

// 函数定义
void printMatrix(int rows, int cols, int matrix[rows][cols]) {
    for(int i=0; i<rows; ++i) {
        for(int j=0; j<cols; ++j) {
            printf("%d ", matrix[i][j]); // 打印矩阵元素
        }
        printf("\n"); // 每行结束后换行
    }
}

        作为返回值

                不能直接返回局部数组，但可以返回指向动态分配数组的指针。

                二维数组不能直接作为函数的返回值，因为函数的返回值是返回给调用者的。

                而二维数组在函数内部创建，无法直接返回给调用者。

                但是，你可以返回指向动态分配数组的指针。

        举个栗子

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

// 函数声明
int **createMatrix(int rows, int cols);

int main() {
    int rows = 3;       // 定义二维数组的行数
    int cols = 4;       // 定义二维数组的列数
    int **matrix = createMatrix(rows, cols); // 调用函数创建二维数组

    // 打印二维数组以验证创建是否成功
    for(int i=0; i<rows; ++i) {
        for(int j=0; j<cols; ++j) {
            printf("%d ", matrix[i][j]); // 打印矩阵元素
        }
        printf("\n"); // 每行结束后换行
    }

    // 释放内存
    for (int i = 0; i < rows; ++i) {
        free(matrix[i]); // 释放每一行的内存
    }
    free(matrix); // 释放行指针数组的内存

    return 0;
}

// 函数定义
int **createMatrix(int rows, int cols) {
    int **matrix = (int **)malloc(rows * sizeof(int *));
    if (matrix == NULL) {
        fprintf(stderr, "Memory allocation failed!\n");
        return NULL;
    }

    // 动态分配每一行的内存
    for (int i = 0; i < rows; ++i) {
        matrix[i] = (int *)malloc(cols * sizeof(int));
        if (matrix[i] == NULL) {
            fprintf(stderr, "Memory allocation failed for row %d!\n", i);
            // 释放之前分配的内存
            for (int j = 0; j < i; ++j) {
                free(matrix[j]);
            }
            free(matrix);
            return NULL;
        }
    }

    // 返回指向动态分配数组的指针
    return matrix;
}

        二维数组的边界检查

                确保索引在数组的合法范围内，避免越界访问。

        二维数组的性能考虑

                访问局部性

                连续访问相邻元素可以优化缓存性能。

        内存对齐

                某些数据类型可能需要按照特定的对齐方式来存储，以提高访问效率。

凭栏落花侧
关注
  • 16
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C语言之二维数组定义、初始化、赋值、求最大最小、求和
jianshuilan_0613的博客
04-28 1万+
数组可以用来存储多个相同类型的数据，并占用多个连续的内存空间来存储数据。二维数组是有两个下标的数组。 1、二维数组定义语法：类型名 数组名[行数][列数]; #includ <stdio.h> #define X 5 #define Y 6 int main() { int a[3][3]; int b[1+4][2+1]; int c = 2; int d = 3; int e[c][d];//不能是变量,会报错 int f[X][Y];//
c语言二维数组
HUYA69的博客
10-17 1229
c语言中经常需要通过函数传递二维数组，有三种方法可以实现，如下： 方法一，形参给出第二维的长度。 例如： #include void func(int n,int a[][size]) { 　　/* access array */ 　　a[i][j]; } void main() { 　　int a[10][10]; 　　func(10, a); } 方法二，形参声...
C语言中的数组（4）---二维数组的定义
weixin_44982036的博客
12-16 5149
二维数组定义语法 定义语法： int arr[2][3] = { {2, 5, 8}, {7, 9 10} }; int arr[3][5] = {{2, 3, 54, 56, 7 }, {2, 67, 4, 35, 9}, {1, 4, 16, 3, 78}}; 大小： 数组大小: sizeof(arr); 一行大小: sizeof (arr[0])： 二维数组的一行，就是一个一维数组。 一个元素大小:sizeof (arr[0][0]) 单位：字节 行数：row = sizeof(arr)/ size
C 语言之二维数组（详细版）
热门推荐
weixin_45332776的博客
06-02 12万+
目录 1.二维数组的定义和初始化 2.二维数组在内存中的存储 3.二维数组的使用 4.二维数组的应用实例
二维数组赋值
weixin_33850890的博客
04-26 2317
#创建二维数据并赋值 lists=[] m=3 n=4 foriinrange(m): lists.append([i]) forjinrange(n): lists[i].append(j) 转载于:https://www.cnblogs.com/tortoise512/p/10773949.html...
学习二维动态数组指针做矩阵运算的方法
09-03
本文将深入探讨如何使用二维动态数组指针来实现矩阵运算，包括矩阵的创建、释放、赋值、加法和减法。 首先，我们需要理解二维动态数组指针的概念。在C/C++中，二维数组通常用于表示矩阵，因为它们提供了类似表格的...
基于指针数组实现二维数组中的查找与显示程序
11-16
- 定义了一个二维数组`a[M][N]`，以及一个指针数组`p1[M]`用于存储每一行的起始地址。 - 使用循环为`p1`中的每个元素赋值，使其指向`a`中对应行的起始位置。 - 调用`getMinRow`函数，传入`p1`和`N`（列数），得到...
C语言数组详解ppt课件.ppt
11-13
在C语言中，数组名不能作为左值，不能用作赋值的左边，但可以用作右值，可以用作函数调用、数组下标运算符、指针运算符等。 例如：int a[10]; a[0]=1;a[1]=2;...，这里的a[0]和a[1]是数组元素的引用。 数组的下标...
单片机C语言实例-用指针数组作为函数的参数显示多个字符串.zip
12-14
4. **定义显示函数**：创建一个函数，如`void displayStrings(char (*strPtrs)[N])`，其中`strPtrs`是一个指向指针数组的指针，也就是一个二维指针。函数的职责是遍历指针数组，逐个显示对应的字符串。 5. **调用...
计算机二级C语言真题.docx 常规C/C++编程
03-27
4. **数组**：数组是存储同类型数据集合的结构，考生需会处理一维和二维数组，包括初始化、遍历以及数组与函数的交互。 5. **指针**：指针是C语言的精髓之一，它能指向变量的地址，实现高效的数据操作。考生应掌握...
【C语言】二维数组（详解）
最新发布
稻草人
06-12 2648
前面我们深入学习了一维数组的相关知识，现在我们开始二维数组的学习之旅吧！1. 二维数组的创建1.1 二维数组的概念前面学习的数组被称为一维数组，数组的元素都是内置类型的，如果我们把一维数组作为数组的元素，这就是二维数组，二维数组作为数组元素的数组被称为三维数组，把二维数组以上的数组统称为多维数组。1.2 二维数组的创建定义二维数组的语法如下：1 type arr_name [常量值1] [常量值2];23 例如：
C语言二维数组的赋值方式
weixin_39084493的博客
03-26 1万+
1 #include<stdio.h> 2 int main(){ 3 /* char chh[]={'a','a','a','a','a','\0'}; 4 printf("%s",chh);*/ 5 //二维数组 6 //在定义时赋值 7 int n...
c语言定二维义数组,C语言二维数组超细讲解
weixin_33924571的博客
05-20 2242
用一维数组处理二维表格，实际是可行的，但是会很复杂，特别是遇到二维表格的输入、处理和输出。在你绞尽脑汁的时候，二维数组(一维数组的大哥)像电视剧里救美的英雄一样显现在你的面前，初识数组的朋友们还等什么呢？让我们认识一下这位武功高强的大哥吧！1. 双下标变量先来认识一下双下标变量，聪明的你一定能够顾名思义了吧，简单举个例子：Array[2][3]Array是数组名,后面的两个方括号内分别放行下标和列...
C语言二维数组
wh_0727的博客
05-01 268
 1.二维数组定义的一般形式是：                                                  类型说明符 数组名[常量表达式1][常量表达式2]常量表达式1表示：第一维下标的长度常量表达式2表示：第二维下标的长度int arr[3][4];在C语言中，二维数组是按行排列的（即行优先）即，先存放a[0]行，再存放a[1]行，最后存放a[2]行。每行中有四个元...
【C语言】二维数组
"謓泽"正在路上朝着"攻城狮"方向"前进四"!
02-10 6万+
前面的博客介绍了一维数组只有一个下标，称为一维数组，其数组元素也称为单下标变量。我们在实际问题当中很多量是由二维或者是多维的，因此 C 语言允许构造了多维数组。多维数组的元素有多个下标，以标识它的数组中的位置，所以也称为多下标变量。本片文章介绍的是二维数组。
C语言编写函数求一个二维数组的最小值。
05-24
可以按照以下步骤编写一个函数来求解二维数组的最小值： 1. 定义一个函数，传入二维数组以及其行数和列数作为参数。 2. 定义一个变量 `min` 用来保存最小值，并初始化为二维数组中的第一个元素。 3. 使用双重循环遍历整个二维数组，从第二个元素开始依次与 `min` 进行比较。 4. 如果当前元素小于 `min`，则将该元素赋值给 `min`。 5. 遍历完成后，返回 `min`。 下面是对应的 C 代码实现： ```c #include <stdio.h> int get_min(int arr[][3], int rows, int cols) { int i, j, min = arr[0][0]; for (i = 0; i < rows; i++) { for (j = 0; j < cols; j++) { if (arr[i][j] < min) { min = arr[i][j]; } } } return min; } int main() { int arr[][3] = {{3, 2, 5}, {1, 9, 4}, {7, 6, 8}}; int rows = 3, cols = 3; int min = get_min(arr, rows, cols); printf("The minimum value is %d\n", min); return 0; } ``` 这里我们定义了一个二维数组 `arr`，其中有三行三列，然后我们调用 `get_min` 函数来求解该数组的最小值。最后在 `main` 函数中输出结果。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值