使用链表从给定的稀疏矩阵生成矩阵并重建稀疏矩阵

本文将介绍如何使用链表来从给定的稀疏矩阵生成完整的矩阵，并且如何通过已有的链表重建稀疏矩阵。稀疏矩阵是指大部分元素都为0的矩阵，因此这种矩阵可以通过链表来存储，避免浪费内存空间。

生成矩阵

我们先来看如何从稀疏矩阵生成完整矩阵。我们可以使用两个链表来存储稀疏矩阵，一个存储行号，另一个存储列号和元素值。下面是代码片段的markdown格式：

// 定义链表节点
struct node{
    int value;
    int row;
    int col;
    struct node* next;
};

// 生成矩阵函数
int** generateMatrix(struct node* row_list, struct node* col_list, int rows, int cols){
    int** matrix = (int**)malloc(rows * sizeof(int*));
    for(int i = 0; i < rows; i++){
        matrix[i] = (int*)malloc(cols * sizeof(int));
        memset(matrix[i], 0, cols*sizeof(int));
    }
    struct node* p = row_list;
    while(p != NULL){
        int row = p->row;
        struct node* q = p->next;
        while(q != NULL && q->row == row){
            matrix[row][q->col] = q->value;
            q = q->next;
        }
        p = q;
    }
    return matrix;
}

该函数首先根据给定的行数和列数动态申请二维数组matrix，并将其所有元素初始化为0。接着从行链表中取出每个行号，再在列链表中搜索行号相同的所有节点，并将元素值存入matrix[row][col]中。最终返回生成的矩阵matrix。

重建稀疏矩阵

现在我们来看如何通过已有的链表重建稀疏矩阵。我们可以首先根据链表中的行号和列号，得到稀疏矩阵的行数和列数。然后再根据链表中的元素值，构建出稀疏矩阵。下面是代码片段的markdown格式：

// 重建稀疏矩阵函数
struct node* buildSparseMatrix(int** matrix, int rows, int cols){
    struct node* row_list = (struct node*)malloc(sizeof(struct node));
    struct node* col_list = (struct node*)malloc(sizeof(struct node));
    row_list->row = -1;
    row_list->next = NULL;
    col_list->col = -1;
    col_list->next = NULL;
    
    for(int i = 0; i < rows; i++){
        struct node* last_row_node = row_list;
        while(last_row_node->next != NULL && last_row_node->next->row < i){
            last_row_node = last_row_node->next;
        }
        for(int j = 0; j < cols; j++){
            if(matrix[i][j] != 0){
                struct node* node = (struct node*)malloc(sizeof(struct node));
                node->value = matrix[i][j];
                node->row = i;
                node->col = j;
                node->next = NULL;
                
                struct node* last_col_node = col_list;
                while(last_col_node->next != NULL && last_col_node->next->col < j){
                    last_col_node = last_col_node->next;
                }
                
                node->next = last_col_node->next;
                last_col_node->next = node;
                
                node->next = last_row_node->next;
                last_row_node->next = node;
            }
        }
    }
    return row_list;
}

该函数首先定义两个链表row_list和col_list，并在其头结点上分别定义行号和列号为-1，示意还未开始处理数据。接着遍历稠密矩阵中的每个元素，如果该元素非0，则将其行号、列号、元素值存入一个新的链表节点中，并将该节点分别插入行链表和列链表中。最终返回行链表row_list。需要注意的是，链表中的节点需要动态申请。

总结

通过上述的代码片段，我们可以实现使用链表从给定的稀疏矩阵生成矩阵并重建稀疏矩阵的功能。链表的优点在于其可以灵活地存储数据，避免浪费空间。当然，链表的缺点也是显而易见的，其查询效率相对较低。