【数据结构】数组和字符串(一):矩阵的数组表示
矩阵是以按行优先次序将所有矩阵元素存放在一个一维数组中。但是对于特殊矩阵,如对称矩阵、三角矩阵、对角矩阵和稀疏矩阵等, 如果用这种方式存储,会出现大量存储空间存放重复信息或零元素的情况,这样会造成很大的空间浪费。为节约存储空间和算法(程序)运行时间,通常会采用压缩存储的方法。
【数据结构】数组和字符串(二):特殊矩阵的压缩存储:对角矩阵——一维数组
【数据结构】数组和字符串(三):特殊矩阵的压缩存储:三角矩阵、对称矩阵——一维数组
对于稀疏矩阵的压缩存储,由于非零元素的个数远小于零元素的个数,并且非零元素的分布没有规律,无法简单地利用一维数组和映射公式来实现压缩存储。针对稀疏矩阵,通常采用特定的数据结构来进行压缩存储,以减少存储空间的占用。
一种常见的稀疏矩阵压缩存储方法是使用"三元组"表示法,也称为COO(Coordinate)格式,只存储非零元素的值以及它们的行列坐标。通过使用三元组(Triplet)来表示非零元素的位置和值,每个三元组包含三个信息:非零元素的行索引、非零元素的列索引以及非零元素的值。
【数据结构】数组和字符串(四):特殊矩阵的压缩存储:稀疏矩阵——三元组表
【数据结构】数组和字符串(七):特殊矩阵的压缩存储:三元组表的转置、加法、乘法操作
在稀疏矩阵的十字链表中,每个非零元素都由一个节点表示。节点包含了几个字段:
LEFT
:指向该节点在同一行中的左邻非零元素的地址信息。UP
:指向该节点在同一列中的上邻非零元素的地址信息。ROW
:存储该节点在矩阵中的行号。COL
:存储该节点在矩阵中的列号。VAL
:存储该节点的元素值。 每一行都有一个表头节点,它引导着该行的循环链表,循环链表中的每个节点按照列号的顺序排列。同样,每一列也有一个表头节点,它引导着该列的循环链表,循环链表中的每个节点按照行号的顺序排列。
关于循环链表: 【数据结构】线性表(三)循环链表的各种操作(创建、插入、查找、删除、修改、遍历打印、释放内存空间)
在稀疏矩阵的十字链表中,每一行和每一列都有一个表头节点。
对于行表头节点 BASEROW[i]
,其中 i
表示行号,范围从 1 到 m
(矩阵的行数)。如果该行为空(即没有非零元素),则 COL(Loc(BASEROW[i]))
的值为 -1。否则,COL(Loc(BASEROW[i]))
的值为该行中最右边的非零元素的列号。
对于列表头节点 BASECOL[j]
,其中 j
表示列号,范围从 1 到 n
(矩阵的列数)。如果该列为空(即没有非零元素),则 ROW(Loc(BASECOL[j]))
的值为 -1。否则,ROW(Loc(BASECOL[j]))
的值为该列中最下边的非零元素的行号。
由于行和列都是循环链表,行表头节点 BASEROW[i]
中的 LEFT
指针循环地链接到该行最右边的非零元素,列表头节点 BASECOL[j]
中的 UP
指针循环地链接到该列最下边的非零元素。
通过这种方式,可以用较少的空间表示稀疏矩阵,并且可以快速地进行行和列的遍历操作。每个节点的 LEFT
和 UP
指针可以用来定位其左邻和上邻非零元素,从而实现矩阵的访问和操作。
【数据结构】数组和字符串(八):稀疏矩阵的链接存储:十字链表的创建、遍历打印(按行、按列、打印矩阵)、销毁
【数据结构】数组和字符串(九):稀疏矩阵的链接存储:十字链表的插入、查找、删除操作
SparseMatrix* matrixAddition(SparseMatrix* matrix1, SparseMatrix* matrix2) {
if (matrix1->rows != matrix2->rows || matrix1->cols != matrix2->cols) {
printf("Matrix dimensions do not match!\n");
return NULL;
}
SparseMatrix* result = createSparseMatrix(matrix1->rows, matrix1->cols);
for (int i = 1; i <= matrix1->rows; i++) {
MatrixNode* node1 = matrix1->rowHeaders[i];
MatrixNode* node2 = matrix2->rowHeaders[i];
while (node1 != NULL && node2 != NULL) {
if (node1->col == node2->col) {
int sum = node1->value + node2->value;
insertElement(result, node1->row, node1->col, sum);
node1 = node1->right;
node2 = node2->right;
} else if (node1->col < node2->col) {
insertElement(result, node1->row, node1->col, node1->value);
node1 = node1->right;
} else {
insertElement(result, node2->row, node2->col, node2->value);
node2 = node2->right;
}
}
while (node1 != NULL) {
insertElement(result, node1->row, node1->col, node1->value);
node1 = node1->right;
}
while (node2 != NULL) {
insertElement(result, node2->row, node2->col, node2->value);
node2 = node2->right;
}
}
return result;
}
SparseMatrix* matrixMultiplication(SparseMatrix* matrix1, SparseMatrix* matrix2) {
if (matrix1->cols != matrix2->rows) {
printf("Matrix dimensions do not match!\n");
return NULL;
}
SparseMatrix* result = createSparseMatrix(matrix1->rows, matrix2->cols);
for (int i = 1; i <= matrix1->rows; i++) {
for (int j = 1; j <= matrix2->cols; j++) {
int sum = 0;
MatrixNode* node1 = matrix1->rowHeaders[i];
MatrixNode* node2 = matrix2->colHeaders[j];
while (node1 != NULL && node2 != NULL) {
if (node1->col == node2->row) {
sum += node1->value * node2->value;
node1 = node1->right;
node2 = node2->down;
} else if (node1->col < node2->row) {
node1 = node1->right;
} else {
node2 = node2->down;
}
}
if (sum != 0) {
insertElement(result, i, j, sum);
}
}
}
return result;
}
SparseMatrix* matrixTranspose(SparseMatrix* matrix) {
SparseMatrix* result = createSparseMatrix(matrix->cols, matrix->rows);
for (int i = 1; i <= matrix->rows; i++) {
MatrixNode* current = matrix->rowHeaders[i];
while (current != NULL) {
insertElement(result, current->col, current->row, current->value);
current = current->right;
}
}
return result;
}
int main() {
// 创建一个5x5的稀疏矩阵
SparseMatrix* matrix1 = createSparseMatrix(5, 5);
// 插入元素
insertElement(matrix1, 1, 3, 5);
insertElement(matrix1, 1, 4, 2);
insertElement(matrix1, 5, 2, 1);
insertElement(matrix1, 5, 1, 8);
insertElement(matrix1, 5, 5, 7);
// 打印稀疏矩阵
printf("\nSparse Matrix 1:\n");
printSparseMatrix(matrix1);
// 创建另一个5x3的稀疏矩阵
SparseMatrix* matrix2 = createSparseMatrix(5, 3);
// 插入元素
insertElement(matrix2, 1, 1, 1);
insertElement(matrix2, 1, 3, 2);
insertElement(matrix2, 2, 2, 3);
insertElement(matrix2, 3, 1, 4);
insertElement(matrix2, 3, 3, 5);
// 打印稀疏矩阵
printf("\nSparse Matrix 2:\n");
printSparseMatrix(matrix2);
// 矩阵加法
SparseMatrix* additionResult = matrixAddition(matrix1, matrix1);
printf("\nMatrix Addition Result:\n");
printSparseMatrix(additionResult);
// 矩阵乘法
SparseMatrix* multiplicationResult = matrixMultiplication(matrix1, matrix2);
printf("\nMatrix Multiplication Result:\n");
printSparseMatrix(multiplicationResult);
// 矩阵转置
SparseMatrix* transposeResult = matrixTranspose(matrix1);
printf("\nMatrix Transpose Result:\n");
printSparseMatrix(transposeResult);
// 销毁稀疏矩阵
destroySparseMatrix(matrix1);
destroySparseMatrix(matrix2);
destroySparseMatrix(additionResult);
destroySparseMatrix(multiplicationResult);
destroySparseMatrix(transposeResult);
return 0;
}
Sparse Matrix 1:
0 0 5 2 0
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
8 1 0 0 7
Sparse Matrix 2:
1 0 2
0 3 0
4 0 5
0 0 0
0 0 0
#include
#include
// 定义矩阵节点结构
typedef struct MatrixNode {
int row;
int col;
int value;
struct MatrixNode* right;
struct MatrixNode* down;
} MatrixNode;
// 定义稀疏矩阵结构
typedef struct SparseMatrix {
int rows;
int cols;
MatrixNode** rowHeaders;
MatrixNode** colHeaders;
} SparseMatrix;
// 创建稀疏矩阵
SparseMatrix* createSparseMatrix(int rows, int cols) {
SparseMatrix* matrix = (SparseMatrix*)malloc(sizeof(SparseMatrix));
matrix->rows = rows;
matrix->cols = cols;
// 创建行表头节点数组
matrix->rowHeaders = (MatrixNode**)malloc((rows + 1) * sizeof(MatrixNode*));
for (int i = 0; i <= rows; i++) {
matrix->rowHeaders[i] = NULL;
}
// 创建列表头节点数组
matrix->colHeaders = (MatrixNode**)malloc((cols + 1) * sizeof(MatrixNode*));
for (int j = 0; j <= cols; j++) {
matrix->colHeaders[j] = NULL;
}
return matrix;
}
// 销毁稀疏矩阵
void destroySparseMatrix(SparseMatrix* matrix) {
if (matrix == NULL) {
return;
}
// 释放所有节点内存
for (int i = 1; i <= matrix->rows; i++) {
MatrixNode* current = matrix->rowHeaders[i];
while (current != NULL) {
MatrixNode* temp = current;
current = current->right;
free(temp);
}
}
// 释放行表头节点数组
free(matrix->rowHeaders);
// 释放列表头节点数组
free(matrix->colHeaders);
// 释放稀疏矩阵结构
free(matrix);
}
// 插入元素
void insertElement(SparseMatrix* matrix, int row, int col, int value) {
if (row <= 0 || row > matrix->rows || col <= 0 || col > matrix->cols) {
printf("Invalid position!\n");
return;
}
// 创建新节点
MatrixNode* newNode = (MatrixNode*)malloc(sizeof(MatrixNode));
newNode->row = row;
newNode->col = col;
newNode->value = value;
newNode->right = NULL;
newNode->down = NULL;
// 插入到行链表
if (matrix->rowHeaders[row] == NULL || matrix->rowHeaders[row]->col > col) {
// 插入到行链表的头部
newNode->right = matrix->rowHeaders[row];
matrix->rowHeaders[row] = newNode;
} else {
MatrixNode* current = matrix->rowHeaders[row];
while (current->right != NULL && current->right->col < col) {
current = current->right;
}
newNode->right = current->right;
current->right = newNode;
}
// 插入到列链表
if (matrix->colHeaders[col] == NULL || matrix->colHeaders[col]->row > row) {
// 插入到列链表的头部
newNode->down = matrix->colHeaders[col];
matrix->colHeaders[col] = newNode;
} else {
MatrixNode* current = matrix->colHeaders[col];
while (current->down != NULL && current->down->row < row) {
current = current->down;
}
newNode->down = current->down;
current->down = newNode;
}
}
// 打印稀疏矩阵
void printSparseMatrix(SparseMatrix* matrix) {
for (int i = 1; i <= matrix->rows; i++) {
MatrixNode* current = matrix->rowHeaders[i];
for (int j = 1; j <= matrix->cols; j++) {
if (current != NULL && current->col == j) {
printf("%d ", current->value);
current = current->right;
} else {
printf("0 ");
}
}
printf("\n");
}
}
// 矩阵加法
SparseMatrix* matrixAddition(SparseMatrix* matrix1, SparseMatrix* matrix2) {
if (matrix1->rows != matrix2->rows || matrix1->cols != matrix2->cols) {
printf("Matrix dimensions do not match!\n");
return NULL;
}
SparseMatrix* result = createSparseMatrix(matrix1->rows, matrix1->cols);
for (int i = 1; i <= matrix1->rows; i++) {
MatrixNode* node1 = matrix1->rowHeaders[i];
MatrixNode* node2 = matrix2->rowHeaders[i];
while (node1 != NULL && node2 != NULL) {
if (node1->col == node2->col) {
int sum = node1->value + node2->value;
insertElement(result, node1->row, node1->col, sum);
node1 = node1->right;
node2 = node2->right;
} else if (node1->col < node2->col) {
insertElement(result, node1->row, node1->col, node1->value);
node1 = node1->right;
} else {
insertElement(result, node2->row, node2->col, node2->value);
node2 = node2->right;
}
}
while (node1 != NULL) {
insertElement(result, node1->row, node1->col, node1->value);
node1 = node1->right;
}
while (node2 != NULL) {
insertElement(result, node2->row, node2->col, node2->value);
node2 = node2->right;
}
}
return result;
}
// 矩阵乘法
SparseMatrix* matrixMultiplication(SparseMatrix* matrix1, SparseMatrix* matrix2) {
if (matrix1->cols != matrix2->rows) {
printf("Matrix dimensions do not match!\n");
return NULL;
}
SparseMatrix* result = createSparseMatrix(matrix1->rows, matrix2->cols);
for (int i = 1; i <= matrix1->rows; i++) {
for (int j = 1; j <= matrix2->cols; j++) {
int sum = 0;
MatrixNode* node1 = matrix1->rowHeaders[i];
MatrixNode* node2 = matrix2->colHeaders[j];
while (node1 != NULL && node2 != NULL) {
if (node1->col == node2->row) {
sum += node1->value * node2->value;
node1 = node1->right;
node2 = node2->down;
} else if (node1->col < node2->row) {
node1 = node1->right;
} else {
node2 = node2->down;
}
}
if (sum != 0) {
insertElement(result, i, j, sum);
}
}
}
return result;
}
// 矩阵转置
SparseMatrix* matrixTranspose(SparseMatrix* matrix) {
SparseMatrix* result = createSparseMatrix(matrix->cols, matrix->rows);
for (int i = 1; i <= matrix->rows; i++) {
MatrixNode* current = matrix->rowHeaders[i];
while (current != NULL) {
insertElement(result, current->col, current->row, current->value);
current = current->right;
}
}
return result;
}
int main() {
// 创建一个5x5的稀疏矩阵
SparseMatrix* matrix1 = createSparseMatrix(5, 5);
// 插入元素
insertElement(matrix1, 1, 3, 5);
insertElement(matrix1, 1, 4, 2);
insertElement(matrix1, 5, 2, 1);
insertElement(matrix1, 5, 1, 8);
insertElement(matrix1, 5, 5, 7);
// 打印稀疏矩阵
printf("\nSparse Matrix 1:\n");
printSparseMatrix(matrix1);
// 创建另一个5x3的稀疏矩阵
SparseMatrix* matrix2 = createSparseMatrix(5, 3);
// 插入元素
insertElement(matrix2, 1, 1, 1);
insertElement(matrix2, 1, 3, 2);
insertElement(matrix2, 2, 2, 3);
insertElement(matrix2, 3, 1, 4);
insertElement(matrix2, 3, 3, 5);
// 打印稀疏矩阵
printf("\nSparse Matrix 2:\n");
printSparseMatrix(matrix2);
// 矩阵加法
SparseMatrix* additionResult = matrixAddition(matrix1, matrix1);
printf("\nMatrix Addition Result:\n");
printSparseMatrix(additionResult);
// 矩阵乘法
SparseMatrix* multiplicationResult = matrixMultiplication(matrix1, matrix2);
printf("\nMatrix Multiplication Result:\n");
printSparseMatrix(multiplicationResult);
// 矩阵转置
SparseMatrix* transposeResult = matrixTranspose(matrix1);
printf("\nMatrix Transpose Result:\n");
printSparseMatrix(transposeResult);
// 销毁稀疏矩阵
destroySparseMatrix(matrix1);
destroySparseMatrix(matrix2);
destroySparseMatrix(additionResult);
destroySparseMatrix(multiplicationResult);
destroySparseMatrix(transposeResult);
return 0;
}