完成稀疏矩阵的初始化，转置，以及两个稀疏矩阵的相加，C语言编程，有注释，完整代码

在C语言中，由于标准库并没有直接提供处理稀疏矩阵的数据结构，我们通常会自定义结构体来表示稀疏矩阵，并使用哈希表（如`struct`结合`void*`指针）存储非零元素及其索引。以下是简化的C语言代码示例，展示了如何完成稀疏矩阵的初始化、转置和相加：

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h> // 用于布尔值

// 稀疏矩阵节点
typedef struct {
    int value;   // 非零元素
    int row, col; // 行和列索引
} SparseMatrixElement;

// 存储稀疏矩阵的自定义数据结构
typedef struct {
    int rows, cols; // 矩阵大小
    SparseMatrixElement** elements;
    size_t num_elements;
} SparseMatrix;

// 初始化稀疏矩阵
SparseMatrix* sparse_matrix_init(int rows, int cols) {
    SparseMatrix* mat = (SparseMatrix*)malloc(sizeof(SparseMatrix));
    mat->rows = rows;
    mat->cols = cols;
    mat->elements = (SparseMatrixElement**)calloc(rows, sizeof(SparseMatrixElement*));
    for (int i = 0; i < rows; i++) {
        mat->elements[i] = NULL;
    }
    mat->num_elements = 0;
    return mat;
}

// 添加非零元素到矩阵
void add_element_to_matrix(SparseMatrix* mat, int row, int col, int value) {
    if (mat->elements[row] == NULL) {
        mat->elements[row] = (SparseMatrixElement*)malloc(sizeof(SparseMatrixElement));
        mat->elements[row]->row = row;
        mat->elements[row]->col = -1; // 初始化列索引为-1
    }

    SparseMatrixElement* elem = (SparseMatrixElement*)mat->elements[row];
    while (elem->col != -1 && elem->col != col) {
        elem = (SparseMatrixElement*)((char*)elem + sizeof(SparseMatrixElement)); // 向后查找空位置
    }
    if (elem->col == col) { // 如果已经存在，更新值
        elem->value += value;
    } else { // 插入新元素
        ++mat->num_elements;
        elem->col = col;
        elem->value = value;
    }
}

// 稀疏矩阵转置
void transpose(SparseMatrix* src, SparseMatrix* dst) {
    assert(src->rows == dst->cols && src->cols == dst->rows);
    dst->rows = src->cols;
    dst->cols = src->rows;
    dst->elements = (SparseMatrixElement**)calloc(dst->rows, sizeof(SparseMatrixElement*));

    for (int j = 0; j < dst->rows; j++) {
        dst->elements[j] = (SparseMatrixElement*)malloc(sizeof(SparseMatrixElement));
        dst->elements[j]->row = j;
        dst->elements[j]->col = -1;
    }

    for (int i = 0; i < src->rows; i++) {
        if (src->elements[i]) {
            for (SparseMatrixElement* elem = src->elements[i]; elem->col != -1; elem = (SparseMatrixElement*)((char*)elem + sizeof(SparseMatrixElement))) {
                add_element_to_matrix(dst, elem->col, i, elem->value); // 转置后交换行和列索引
            }
        }
    }
    dst->num_elements = src->num_elements;
}

// 稀疏矩阵相加
void sparse_matrix_addition(SparseMatrix* a, SparseMatrix* b, SparseMatrix* result) {
    assert(a->rows == b->rows && a->rows == result->rows && a->cols == b->cols && a->cols == result->cols);

    for (int i = 0; i < a->rows; i++) {
        if (a->elements[i] && b->elements[i]) {
            add_element_to_matrix(result, i, a->elements[i]->col, a->elements[i]->value + b->elements[i]->value);
        }
    }
}

// 打印稀疏矩阵
void print_sparse_matrix(const SparseMatrix* mat) {
    for (int i = 0; i < mat->rows; i++) {
        printf("Row %d:\n", i);
        SparseMatrixElement* elem = mat->elements[i];
        while (elem) {
            printf("(%d, %d): %d ", elem->row, elem->col, elem->value);
            elem = (SparseMatrixElement*)((char*)elem + sizeof(SparseMatrixElement));
        }
        printf("\n");
    }
}

int main() {
    int rows = 4, cols = 5;
    SparseMatrix* mat_a = sparse_matrix_init(rows, cols);
    // ... 实现添加非零元素到mat_a ...

    SparseMatrix* mat_b = sparse_matrix_init(rows, cols);
    // ... 实现添加非零元素到mat_b ...

    SparseMatrix* mat_c = sparse_matrix_init(rows, cols);
    sparse_matrix_addition(mat_a, mat_b, mat_c);

    printf("Matrix A:\n");
    print_sparse_matrix(mat_a);
    printf("Matrix B:\n");
    print_sparse_matrix(mat_b);
    printf("Matrix C (A + B):\n");
    print_sparse_matrix(mat_c);

    free(mat_a->elements);
    free(mat_a);
    free(mat_b->elements);
    free(mat_b);
    free(mat_c->elements);
    free(mat_c);

    return 0;
}

请注意，这是一个简化版本的代码，实际应用中可能需要考虑内存管理和错误处理。此外，这个代码假设矩阵是非对称的，如果你的矩阵是对称的，可以在转置函数中优化。最后的`main()`函数仅作为演示用，你需要自己填充添加非零元素的部分。