数据结构：数组

概念：

类似于线性表。

对于二维数组，我们可以把其看做成是这样一个线性表：它的每个数据元素也是一个定长的线性表。例如：一个矩阵，我们可以以行为向量,把每一行看作是一个元素，也可以一列为向量把每一列看作是一个元素，此时二维数组就可以看做是一个线型表。即以行为主序或以列为主序。

以行为主序，假设每个元素占L个存储单元二维数组中任意一个元素的位置aji可以表示为

LOC(i,j)=LOC(0,0)+(b2Xi+j)L

2.基本操作：

1. 访问：通过索引直接访问元素，时间复杂度为 O(1)。

2. 插入：在指定位置插入元素，可能需要移动后续元素，时间复杂度为 O(n)。

3. 删除：删除指定位置的元素，可能需要移动后续元素，时间复杂度为 O(n)。

4. 更新：修改指定位置的元素，时间复杂度为 O(1)。

5. 查找：遍历数组查找元素，时间复杂度为 O(n)。

3.代码实现：

1. 数组的常见操作

#include 

// 打印数组的函数
void printArray(int arr[], int size) {
    for (int i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
}

int main() {
    // 声明并初始化数组
    int numbers[5] = {10, 20, 30, 40, 50};

    // 访问元素
    printf("第三个元素: %d\n", numbers[2]);  // 输出: 30

    // 修改元素
    numbers[1] = 100;
    printf("修改后的数组: ");
    printArray(numbers, 5);  // 输出: 10 100 30 40 50

    // 计算数组长度
    int length = sizeof(numbers) / sizeof(numbers[0]);
    printf("数组长度: %d\n", length);  // 输出: 5

    return 0;
}

运行结果

第三个元素: 30
修改后的数组: 10 100 30 40 50 
数组长度: 5

2.稀疏矩阵的转制

1. 三元组表

三元组表是一种常见的稀疏矩阵存储方式，用三个数组分别存储非零元素的行索引、列索引和值。

例如，矩阵：

0 0 3
0 0 0
4 0 0

可以表示为：

• 行索引数组：row = {0, 2}

• 列索引数组：col = {2, 0}

• 值数组：value = {3, 4}

C语言实现稀疏矩阵转置的示例：

#include 
#include 

// 定义三元组结构
typedef struct {
    int row;
    int col;
    int value;
} Triple;

// 定义稀疏矩阵结构
typedef struct {
    int rows;
    int cols;
    int numNonZero;  // 非零元素个数
    Triple* data;    // 三元组数组
} SparseMatrix;

// 转置函数
SparseMatrix transpose(SparseMatrix matrix) {
    SparseMatrix result;
    result.rows = matrix.cols;  // 转置后行数等于原列数
    result.cols = matrix.rows;  // 转置后列数等于原行数
    result.numNonZero = matrix.numNonZero;
    result.data = (Triple*)malloc(result.numNonZero * sizeof(Triple));

    // 交换行和列索引
    for (int i = 0; i < matrix.numNonZero; i++) {
        result.data[i].row = matrix.data[i].col;
        result.data[i].col = matrix.data[i].row;
        result.data[i].value = matrix.data[i].value;
    }

    // 按新的行索引排序（简单冒泡排序）
    for (int i = 0; i < result.numNonZero - 1; i++) {
        for (int j = 0; j < result.numNonZero - i - 1; j++) {
            if (result.data[j].row > result.data[j + 1].row) {
                // 交换三元组
                Triple temp = result.data[j];
                result.data[j] = result.data[j + 1];
                result.data[j + 1] = temp;
            }
        }
    }

    return result;
}

// 打印稀疏矩阵
void printSparseMatrix(SparseMatrix matrix) {
    printf("行\t列\t值\n");
    for (int i = 0; i < matrix.numNonZero; i++) {
        printf("%d\t%d\t%d\n", matrix.data[i].row, matrix.data[i].col, matrix.data[i].value);
    }
}

int main() {
    // 定义一个稀疏矩阵
    SparseMatrix matrix;
    matrix.rows = 3;
    matrix.cols = 3;
    matrix.numNonZero = 2;
    matrix.data = (Triple*)malloc(matrix.numNonZero * sizeof(Triple));

    // 初始化稀疏矩阵的非零元素
    matrix.data[0].row = 0;
    matrix.data[0].col = 2;
    matrix.data[0].value = 3;

    matrix.data[1].row = 2;
    matrix.data[1].col = 0;
    matrix.data[1].value = 4;

    printf("原矩阵：\n");
    printSparseMatrix(matrix);

    // 转置矩阵
    SparseMatrix transposedMatrix = transpose(matrix);

    printf("\n转置后的矩阵：\n");
    printSparseMatrix(transposedMatrix);

    // 释放内存
    free(matrix.data);
    free(transposedMatrix.data);

    return 0;
}

运行结果：

原矩阵：
行	列	值
0	2	3
2	0	4

转置后的矩阵：
行	列	值
0	2	4
2	0	3

4.应用场景：

• 数据存储：存储固定数量的同类型数据。

• 算法实现：如排序、查找等。

• 矩阵运算：多维数组用于矩阵操作。

5.优缺点：

优点：

• 随机访问速度快。

• 内存连续，缓存友好。

缺点：

• 大小固定，灵活性差。

• 插入和删除效率低。