正文

轻松掌握C语言，稀疏矩阵创建全攻略：从基础到实战

/0 浏览量
1108

引言

稀疏矩阵是数学和计算机科学中常见的一种数据结构，它在处理大型稀疏数据集时，可以显著减少内存占用和提高计算效率。C语言作为一种高效的编程语言，非常适合用于实现稀疏矩阵的创建和处理。本文将带领你从稀疏矩阵的基础知识开始，逐步深入到实战应用，让你轻松掌握C语言中稀疏矩阵的创建。

稀疏矩阵基础知识

什么是稀疏矩阵？

稀疏矩阵是指矩阵中大部分元素为0的矩阵。在现实世界中，很多实际问题都可以用稀疏矩阵来表示，如网络图、图像处理等。

稀疏矩阵的存储方式

由于稀疏矩阵中大部分元素为0，因此可以使用多种方式来存储，常见的有：

  • 三元组表（COO）：使用三个数组分别存储非零元素的行索引、列索引和值。
  • 压缩行存储（CSR）：将矩阵压缩成三个一维数组，分别存储非零元素的行索引、列值和行指针。
  • 压缩列存储（CSC）：与CSR类似，但将列索引和列值存储在一维数组中。

C语言中稀疏矩阵的创建

三元组表（COO）创建稀疏矩阵

以下是一个使用COO存储方式创建稀疏矩阵的C语言示例代码：

#include <stdio.h>

#define MAX_ROWS 100
#define MAX_COLS 100
#define MAX_NONZEROS 1000

typedef struct {
    int row;
    int col;
    double value;
} Element;

typedef struct {
    int rows;
    int cols;
    int nums;
    Element *elements;
} SparseMatrix;

// 创建稀疏矩阵
SparseMatrix createSparseMatrix(int rows, int cols, int nums, Element *elements) {
    SparseMatrix sm;
    sm.rows = rows;
    sm.cols = cols;
    sm.nums = nums;
    sm.elements = (Element *)malloc(nums * sizeof(Element));
    for (int i = 0; i < nums; i++) {
        sm.elements[i] = elements[i];
    }
    return sm;
}

// 打印稀疏矩阵
void printSparseMatrix(SparseMatrix sm) {
    for (int i = 0; i < sm.nums; i++) {
        printf("(%d, %d, %f)\n", sm.elements[i].row, sm.elements[i].col, sm.elements[i].value);
    }
}

int main() {
    int rows = 3, cols = 3, nums = 3;
    Element elements[] = {
        {0, 0, 1.0},
        {1, 1, 2.0},
        {2, 2, 3.0}
    };
    SparseMatrix sm = createSparseMatrix(rows, cols, nums, elements);
    printSparseMatrix(sm);
    return 0;
}

压缩行存储（CSR）创建稀疏矩阵

以下是一个使用CSR存储方式创建稀疏矩阵的C语言示例代码：

#include <stdio.h>

#define MAX_ROWS 100
#define MAX_COLS 100
#define MAX_NONZEROS 1000

typedef struct {
    int row;
    int col;
    double value;
} Element;

typedef struct {
    int rows;
    int cols;
    int *rowPtr;
    int *colInd;
    double *values;
} SparseMatrixCSR;

// 创建稀疏矩阵
SparseMatrixCSR createSparseMatrixCSR(int rows, int cols, int nums, Element *elements) {
    SparseMatrixCSR smcsr;
    smcsr.rows = rows;
    smcsr.cols = cols;
    smcsr.rowPtr = (int *)malloc((rows + 1) * sizeof(int));
    smcsr.colInd = (int *)malloc(nums * sizeof(int));
    smcsr.values = (double *)malloc(nums * sizeof(double));

    int *rowPtr = smcsr.rowPtr;
    int *colInd = smcsr.colInd;
    double *values = smcsr.values;

    for (int i = 0; i < nums; i++) {
        rowPtr[elements[i].row] = i;
        colInd[i] = elements[i].col;
        values[i] = elements[i].value;
    }

    rowPtr[rows] = nums;
    return smcsr;
}

// 打印稀疏矩阵
void printSparseMatrixCSR(SparseMatrixCSR smcsr) {
    for (int i = 0; i <= smcsr.rows; i++) {
        for (int j = smcsr.rowPtr[i]; j < smcsr.rowPtr[i + 1]; j++) {
            printf("(%d, %d, %f)\n", i, smcsr.colInd[j], smcsr.values[j]);
        }
    }
}

int main() {
    int rows = 3, cols = 3, nums = 3;
    Element elements[] = {
        {0, 0, 1.0},
        {1, 1, 2.0},
        {2, 2, 3.0}
    };
    SparseMatrixCSR smcsr = createSparseMatrixCSR(rows, cols, nums, elements);
    printSparseMatrixCSR(smcsr);
    return 0;
}

稀疏矩阵的运算

稀疏矩阵的运算主要包括矩阵加法、矩阵乘法、转置等。以下是一个使用COO存储方式实现矩阵加法的C语言示例代码：

#include <stdio.h>

#define MAX_ROWS 100
#define MAX_COLS 100
#define MAX_NONZEROS 1000

typedef struct {
    int row;
    int col;
    double value;
} Element;

typedef struct {
    int rows;
    int cols;
    int nums;
    Element *elements;
} SparseMatrix;

// 矩阵加法
SparseMatrix addSparseMatrices(SparseMatrix sm1, SparseMatrix sm2) {
    SparseMatrix result;
    result.rows = sm1.rows;
    result.cols = sm1.cols;
    result.nums = 0;
    result.elements = (Element *)malloc(MAX_NONZEROS * sizeof(Element));

    // 比较两个稀疏矩阵的非零元素
    for (int i = 0, j = 0; i < sm1.nums && j < sm2.nums; ) {
        if (sm1.elements[i].row < sm2.elements[j].row || (sm1.elements[i].row == sm2.elements[j].row && sm1.elements[i].col < sm2.elements[j].col)) {
            result.elements[result.nums++] = sm1.elements[i++];
        } else if (sm1.elements[i].row > sm2.elements[j].row || (sm1.elements[i].row == sm2.elements[j].row && sm1.elements[i].col > sm2.elements[j].col)) {
            result.elements[result.nums++] = sm2.elements[j++];
        } else {
            double sum = sm1.elements[i].value + sm2.elements[j].value;
            if (sum != 0.0) {
                result.elements[result.nums++] = (Element){sm1.elements[i].row, sm1.elements[i].col, sum};
            }
            i++;
            j++;
        }
    }

    // 添加剩余的非零元素
    while (i < sm1.nums) {
        result.elements[result.nums++] = sm1.elements[i++];
    }
    while (j < sm2.nums) {
        result.elements[result.nums++] = sm2.elements[j++];
    }

    return result;
}

// 打印稀疏矩阵
void printSparseMatrix(SparseMatrix sm) {
    for (int i = 0; i < sm.nums; i++) {
        printf("(%d, %d, %f)\n", sm.elements[i].row, sm.elements[i].col, sm.elements[i].value);
    }
}

int main() {
    // 创建两个稀疏矩阵
    int rows = 3, cols = 3, nums1 = 3, nums2 = 3;
    Element elements1[] = {
        {0, 0, 1.0},
        {1, 1, 2.0},
        {2, 2, 3.0}
    };
    Element elements2[] = {
        {0, 0, 4.0},
        {1, 1, 5.0},
        {2, 2, 6.0}
    };
    SparseMatrix sm1 = createSparseMatrix(rows, cols, nums1, elements1);
    SparseMatrix sm2 = createSparseMatrix(rows, cols, nums2, elements2);

    // 矩阵加法
    SparseMatrix result = addSparseMatrices(sm1, sm2);

    // 打印结果
    printSparseMatrix(result);

    return 0;
}

总结

通过本文的学习，相信你已经对C语言中稀疏矩阵的创建和运算有了较为深入的了解。在实际应用中，稀疏矩阵可以大大提高计算效率，特别是在处理大型稀疏数据集时。希望本文能帮助你轻松掌握C语言中稀疏矩阵的创建，为你的编程之路添砖加瓦。

-- 展开阅读全文 --