稀疏矩阵的处理（c语言）

已于 2023-04-12 11:31:48 修改
阅读量1.4k 收藏 8
点赞数 5
分类专栏： 数据结构 文章标签： 矩阵 c语言 算法 数据结构
于 2021-12-18 21:28:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52118067/article/details/121942965
版权

这道题是真的折磨我太久了，之前有个测试用例一直没过，发现主要是矩阵乘法上面有点小问题，换了个思路，总算解决了，代码可能不够简洁，主要是在输出上比较繁琐，参考就可以，题挺恶心的，特别是对格式的要求等等在这里插入图片描述

文章目录

题目：

特殊矩阵在采用二维数组存储时，尽管矩阵操作的算法都很简单，但是其空间的利用率很低。 稀疏矩阵就是一种应用很广泛的特殊的矩阵。通常稀疏矩阵在处理时都采用“压缩”存储，即把稀疏矩阵的非零元素抽象成为一个以三元组（行，列，值）为数据元素的线性表来处理，此线性表可以采用顺序存储，也可以采用链式存储。现要求编程实现稀疏矩阵在“压缩”存储时的常用操作，如输出、转置、求和、乘等。

现要求编程实现稀疏矩阵在“压缩”存储时的矩阵的常用操作，如输出、转置、求和、乘等。 即输入两个矩阵，完成如下操作：
(1) 转置。对第一个矩阵进行转置并输出，前面输出标题 “The transformed matrix is:”
(2) 矩阵加。如两个矩阵可以相加，进行两个矩阵的加运算并输出，前面输出标题 “The added matrix is:”；如果不能相加，则输出 “Can not add!”；
(3) 矩阵乘。如果两个矩阵可以相乘，进行两个矩阵的乘并输出，前面输出标题 “The product matrix is:”； 如果不能相乘，则输出 “Can not multiply!”

输入格式:

输入有多行，第1行包括三个整数，分别是矩阵的大小m,n及非零元素的个数r。后面r行分别输入各个非零元素的 行、列、值。

输出格式:

输出有两种形式，操作时分别用符号“L”、“H”指出输出形式。 L: 以三元组的形式输出，即先输出矩阵的行数、列数和非零元素个数，再按行主序依次输出各个非零元素的行、列和值。各输出项之间空格分隔。 H: 按人们习惯的矩阵格式输出，即输出一个mn的矩阵，是零元素的输出0，非零元素输出元素值。设定每个元素占位宽度为4。（要输出矩阵的行号和列号，并对齐）

输入样例:

输入样例1：

10 8 4 
1 8 1
3 3 2 
3 7 3 
10 1 4 
10 8 2 
2 6 1 
3 7 -3
H

输入样例2：

100 90 5
1 10 100
50 60 200
50 80 100
60 60 200
99 89 10
100 90 4
1 1 10
50 60 -200
50 80 100
70 70 10
L

输出样例:

输出样例1：

The transformed matrix is:
       1   2   3   4   5   6   7   8   9  10
   1   0   0   0   0   0   0   0   0   0   4
   2   0   0   0   0   0   0   0   0   0   0
   3   0   0   2   0   0   0   0   0   0   0
   4   0   0   0   0   0   0   0   0   0   0
   5   0   0   0   0   0   0   0   0   0   0
   6   0   0   0   0   0   0   0   0   0   0
   7   0   0   3   0   0   0   0   0   0   0
   8   1   0   0   0   0   0   0   0   0   0
The added matrix is:
       1   2   3   4   5   6   7   8
   1   0   0   0   0   0   0   0   1
   2   0   0   0   0   0   1   0   0
   3   0   0   2   0   0   0   0   0
   4   0   0   0   0   0   0   0   0
   5   0   0   0   0   0   0   0   0
   6   0   0   0   0   0   0   0   0
   7   0   0   0   0   0   0   0   0
   8   0   0   0   0   0   0   0   0
   9   0   0   0   0   0   0   0   0
  10   4   0   0   0   0   0   0   0
Can not multiply!

输出样例2：

The transformed matrix is:
Rows=90,Cols=100,r=5
10 1 100
60 50 200
60 60 200
80 50 100
89 99 10
The added matrix is:
Rows=100,Cols=90,r=6
1 1 10
1 10 100
50 80 200
60 60 200
70 70 10
99 89 10
Can not multiply!

再附上一个测试用例：

input：

3 3 7
1 1 3
1 2 2
2 1 2
2 2 3
2 3 2
3 2 2
3 3 3
3 3 7
1 1 1
1 3 3
2 2 2
2 3 4
3 1 3
3 2 4
3 3 3
L

output

The transformed matrix is:
Rows=3,Cols=3,r=7
1 1 3
1 2 2
2 1 2
2 2 3
2 3 2
3 2 2
3 3 3
The added matrix is:
Rows=3,Cols=3,r=9
1 1 4
1 2 2
1 3 3
2 1 2
2 2 5
2 3 6
3 1 3
3 2 6
3 3 6
The product matrix is:
Rows=3,Cols=3,r=9
1 1 3
1 2 4
1 3 17
2 1 8
2 2 14
2 3 24
3 1 9
3 2 16
3 3 17

思路：

用了两个结构体实现稀疏矩阵三元组的存储方式，然后就是分别实现转置、加法和乘法，根据要求输出（变态格式）具体的解析直接加在代码中了

代码：

结构体定义及函数声明

#include<stdio.h>
#include <malloc.h>
typedef int ElemType;
#define MAXSIZE 100
typedef struct {
	int i, j;       //该非零元的行下标和列下标
	ElemType e;     //数据域
}Triple;
typedef struct {
	Triple data[MAXSIZE]; 		//非零元三元组表
	int mu, nu, tu;           //矩阵的行数，列数和非零元个数
}TSMatrix;
void GreateSMatrix(TSMatrix* M);	//创建
void TransposeSMatrix(TSMatrix* M, TSMatrix* T);//转置
void PrintzhuanH(TSMatrix* T);//H类型输出转置矩阵
void PrintzhuanL(TSMatrix* T);//L类型输出转置矩阵
void PrintADDL(TSMatrix* T);//L类型输出和矩阵
void PrintADDH(TSMatrix* T);//H类型输出和矩阵
void PrintmultiplyL(TSMatrix* T);//L类型输出乘矩阵
void PrintmultiplyH(TSMatrix* T);//H类型输出乘矩阵
bool ADD(TSMatrix* A, TSMatrix* B, TSMatrix* C);//矩阵加
bool multiply(TSMatrix* A, TSMatrix* B, TSMatrix* C);//矩阵乘

主函数

int main() {
	char LH2;
	char LH;
	TSMatrix* M = (TSMatrix*)malloc(sizeof(TSMatrix));
	TSMatrix* T = (TSMatrix*)malloc(sizeof(TSMatrix));
	GreateSMatrix(M);
	TransposeSMatrix(M, T);
	TSMatrix* M2 = (TSMatrix*)malloc(sizeof(TSMatrix));

	GreateSMatrix(M2);
	scanf("%c", &LH2);
	LH = getchar();
	TSMatrix* A = (TSMatrix*)malloc(sizeof(TSMatrix));
    A->tu = 0;
    TSMatrix* MU = (TSMatrix*)malloc(sizeof(TSMatrix));

	if (LH == 'L')
	{
		PrintzhuanL(T);//转置
	}
	else {
		PrintzhuanH(T);
	}

    if (ADD(M, M2, A)) {
		if (LH == 'L')
		{
			PrintADDL(A);
		}
		else {
			PrintADDH(A);
		}
    }
    else {
        printf("Can not add!\n");
    }

    if (multiply(M, M2, MU)) {
		if (LH == 'L') {
			PrintmultiplyL(MU);
		}
		else {
			PrintmultiplyH(MU);
		}
    }
    else {
        printf("Can not multiply!");
    }
	return 0;
}

创建稀疏矩阵

void GreateSMatrix(TSMatrix* M) //创建稀疏矩阵M
{
	scanf("%d %d %d", &M->mu, &M->nu, &M->tu);
	if ((M->mu) > 0 && (M->nu) > 0) {
		if (M->tu < MAXSIZE)
		{
			for (int i = 1; i <= M->tu; i++) {
				scanf("%d %d %d", &M->data[i].i, &M->data[i].j, &M->data[i].e);
			}
		}
	}
}

求转置矩阵

void TransposeSMatrix(TSMatrix* M, TSMatrix* T)//求稀疏矩阵M的转置矩阵T
{
	T->mu = M->nu, T->nu = M->mu, T->tu = M->tu;
	if (T->tu) {
		int q = 0, p, j;
			for (p = 1; p <= M->tu; p++){
					T->data[q].i = M->data[p].j;
					T->data[q].j = M->data[p].i;
					T->data[q].e = M->data[p].e;
					++q;
				}
	}
}

求和矩阵

void EnterTriple(TSMatrix* Q, int row, int col, int e)
{
    Q->data[Q->tu].i = row;
    Q->data[Q->tu].j = col;
    Q->data[Q->tu].e = e;
    Q->tu++;
}
bool ADD(TSMatrix* A, TSMatrix* B, TSMatrix* C)
{
    if (A->mu == B->mu && A->nu == B->nu) {//判断是不是相同形式的矩阵
        C->mu = A->mu; C->nu = A->nu;
        int i = 1, j = 1;
        while (i <= A->tu && j <= B->tu)
        {
            if (A->data[i].i < B->data[j].i)//判断A的行数是否比B小
            {
                EnterTriple(C, A->data[i].i, A->data[i].j, A->data[i].e);
                i++;
            }
            else if (A->data[i].i == B->data[j].i)//行数相等判断列数
            {
                if (A->data[i].j < B->data[j].j)
                {
                    EnterTriple(C, A->data[i].i, A->data[i].j, A->data[i].e);
                    i++;
                }
                else if (A->data[i].j > B->data[j].j)
                {
                    EnterTriple(C, B->data[j].i, B->data[j].j, B->data[j].e);
                    j++;
                }
                else
                {
                    if (B->data[j].e + A->data[i].e != 0)
                        EnterTriple(C, B->data[j].i, B->data[j].j, B->data[j].e + A->data[i].e);
                    i++;
                    j++;
                }
            }
            else
            {
                EnterTriple(C, B->data[j].i, B->data[j].j, B->data[j].e);
                j++;
            }
        }
        while (i <= A->tu)
        {
            EnterTriple(C, A->data[i].i, A->data[i].j, A->data[i].e);
            i++;
        }
        while (j <= B->tu)
        {
            EnterTriple(C, B->data[j].i, B->data[j].j, B->data[j].e);
            j++;
        }
        return true;
    }
    else {
        return false;
    }
}

求乘法矩阵

附上i，j，k三个参数的遍历方式图
在这里插入图片描述

bool multiply(TSMatrix* A, TSMatrix* B, TSMatrix* C)//矩阵相乘
{
	if (A->nu != B->mu)                                    //前矩阵列数要等于后矩阵行数
		return false;
	C->mu = A->mu;                                         //结果矩阵的行数为前矩阵行数
	C->nu = B->nu;	
	C->tu = 0;
	int p, q, x, cnt;
	int i1, j1;
	int sum;
	cnt = 0;
	for (int i = 1; i <= A->mu; i++)
	{

		for (int j = 1; j <= B->nu; j++)//遍历每行每列
		{
			sum = 0;
			for (int k = 1; k <= A->nu; k++)//每个行与每个列单个数的遍历
			{
				p = 0; q = 0;
				for (i1 = 0; i1 <= A->tu; i1++) {  //遍历A找符合i行k列的数
					if (A->data[i1].i == i && A->data[i1].j == k) p = A->data[i1].e;
				}
				for (j1 = 0; j1 <= B->tu; j1++) {//遍历B找符合k行j列的数
					if (B->data[j1].i == k && B->data[j1].j == j) q = B->data[j1].e;
				}
				sum = sum + (p * q);
			}
			if (sum != 0) {
				C->data[cnt].e = sum;
				C->data[cnt].i = i;
				C->data[cnt].j = j;
				cnt++;
			}

		}
	}
	C->tu = cnt;
	return true;
}

输出函数

有6个输出函数，分别对应转置，和矩阵，乘法矩阵的H和L两种输出模式

  1. 在三元组的输出模式下，需要进行行主序的排序，用了个比较简单的冒泡排序
  2. 在矩阵表的输出模式下对空格的要求很严格，最多占位宽度为4，所以可能的数字有7种情况，正数的1、2、3、4位数和负数的1、2、3位数（负号是一个占位宽度）（例：1、10、100、1000、-1、-10、-100）其实这里可以简化，就交给你们了在这里插入图片描述
void PrintzhuanL(TSMatrix* T) //输出矩阵
{
	TSMatrix* zhong = (TSMatrix*)malloc(sizeof(TSMatrix));
	TSMatrix* te = (TSMatrix*)malloc(sizeof(TSMatrix));
	printf("The transformed matrix is:\n");
	printf("Rows=%d,Cols=%d,r=%d\n", T->mu, T->nu, T->tu);
	//冒泡排序
	for (int i = 1; i < T->tu; i++) {
		for (int j = 1; j < T->tu; j++) {
			if (T->data[i].i < T->data[j].i) {
				zhong->data[0] = T->data[i];
				T->data[i] = T->data[j];
				T->data[j] = zhong->data[0];
			}
			else if (T->data[i].i == T->data[j].i) {
				if (T->data[i].j < T->data[j].j) {
					te->data[0] = T->data[i];
					T->data[i] = T->data[j];
					T->data[j] = te->data[0];
				}
			}
		}
	}
	for (int i = 0; i < T->tu; i++) {
		printf("%d %d %d", T->data[i].i, T->data[i].j, T->data[i].e);
		printf("\n");
	}
}
void PrintzhuanH(TSMatrix* T) {
	printf("The transformed matrix is:\n");
	int** data = (int**)malloc(sizeof(int*) * 100);
	for (int i = 0; i < 100; ++i)
	{
		data[i] = (int*)malloc(sizeof(int) * 100);
	}
	int cnt = 1;
	for (int i = 0; i <= T->mu; i++) {
		for (int j = 0; j <= T->nu; j++) {
			data[i][j] = 0;
		}
	}
	for (int i = 0; i < T->tu; i++) {	//在指定位置存放非0元，其余位置都为0
		data[T->data[i].i][T->data[i].j] = T->data[i].e;
	}
	printf("    ");
	for (int i = 1; i <= T->nu; i++) {
		if (i < 10) {
			printf("   %d", i);
		}
		else if (i < 100) {
			printf("  %d", i);
		}
		else if (i < 1000) {
			printf(" %d", i);
		}
	}
	printf("\n");
	for (int i = 1; i <= T->mu; i++) {
		for (int j = 0; j <= T->nu; j++) {
			if (j == 0) {
				if (cnt < 10) {
					printf("   %d", cnt);
				}
				else if (cnt < 100) {
					printf("  %d", cnt);
				}
				else if (cnt < 1000) {
					printf("  %d", cnt);
				}
				cnt++;
			}
			else {
				if (data[i][j] >= 0) {
					if (data[i][j] < 10) {
						printf("   %d", data[i][j]);
					}
					else if (data[i][j] < 100) {
						printf("  %d", data[i][j]);
					}
					else if (data[i][j] < 1000) {
						printf(" %d", data[i][j]);
					}
				}
				else {
					if (data[i][j] > -10) {
						printf("  %d", data[i][j]);
					}
					else if (data[i][j] >-100) {
						printf(" %d", data[i][j]);
					}
					else if (data[i][j] >-1000) {
						printf("%d", data[i][j]);
					}
				}
			}
		}
		printf("\n");
	}
}
void PrintADDL(TSMatrix* T) //输出和矩阵
{
    printf("The added matrix is:\n");
    printf("Rows=%d,Cols=%d,r=%d\n", T->mu, T->nu, T->tu);
	TSMatrix* zhong1 = (TSMatrix*)malloc(sizeof(TSMatrix));
	TSMatrix* te1 = (TSMatrix*)malloc(sizeof(TSMatrix));
		//冒泡排序
	for (int i = 1; i < T->tu; i++) {
		for (int j = 1; j < T->tu; j++) {
			if (T->data[i].i < T->data[j].i) {
				zhong1->data[0] = T->data[i];
				T->data[i] = T->data[j];
				T->data[j] = zhong1->data[0];
			}
			else if (T->data[i].i == T->data[j].i) {
				if (T->data[i].j < T->data[j].j) {
					te1->data[0] = T->data[i];
					T->data[i] = T->data[j];
					T->data[j] = te1->data[0];
				}
			}
		}
	}
    for (int i = 0; i < T->tu; i++) {
        printf("%d %d %d", T->data[i].i, T->data[i].j, T->data[i].e);
        printf("\n");
    }
}
void PrintADDH(TSMatrix* T) {
	printf("The added matrix is:\n");
	int** data1 = (int**)malloc(sizeof(int*) * 100);
	for (int i = 0; i < 100; ++i)
	{
		data1[i] = (int*)malloc(sizeof(int) * 100);
	}
	int cnt = 1;
	for (int i = 0; i <= T->mu; i++) {
		for (int j = 0; j <= T->nu; j++) {
			data1[i][j] = 0;
		}
	}
	for (int i = 0; i < T->tu; i++) {	//在指定位置存放非0元，其余位置都为0
		data1[T->data[i].i][T->data[i].j] = T->data[i].e;
	}
	printf("    ");
	for (int i = 1; i <= T->nu; i++) {
		if (i < 10) {
			printf("   %d", i);
		}
		else if (i < 100) {
			printf("  %d",i);
		}
		else if (i < 1000) {
			printf(" %d",i);
		}
	}
	printf("\n");
	for (int i = 1; i <= T->mu; i++) {
		for (int j = 0; j <= T->nu; j++) {
			if (j == 0) {
				if (cnt < 10) {
					printf("   %d", cnt);
				}
				else if (cnt < 100) {
					printf("  %d", cnt);
				}
				else if (cnt < 1000) {
					printf("  %d", cnt);
				}
				cnt++;
			}
			else {
				if (data1[i][j] >= 0) {
					if (data1[i][j] < 10) {
						printf("   %d", data1[i][j]);
					}
					else if (data1[i][j] < 100) {
						printf("  %d", data1[i][j]);
					}
					else if (data1[i][j] < 1000) {
						printf(" %d", data1[i][j]);
					}
				}
				else {
					if (data1[i][j] > -10) {
						printf("  %d", data1[i][j]);
					}
					else if (data1[i][j] > -100) {
						printf(" %d", data1[i][j]);
					}
					else if (data1[i][j] > -1000) {
						printf("%d", data1[i][j]);
					}
				}
			}
		}
		printf("\n");
	}
}
void PrintmultiplyL(TSMatrix* T) {
	printf("The product matrix is:\n");
	printf("Rows=%d,Cols=%d,r=%d\n", T->mu, T->nu, T->tu);
	TSMatrix* zhong2 = (TSMatrix*)malloc(sizeof(TSMatrix));
	TSMatrix* te2 = (TSMatrix*)malloc(sizeof(TSMatrix));
		//冒泡排序
	for (int i = 1; i < T->tu; i++) {
		for (int j = 1; j < T->tu; j++) {
			if (T->data[i].i < T->data[j].i) {
				zhong2->data[0] = T->data[i];
				T->data[i] = T->data[j];
				T->data[j] = zhong2->data[0];
			}
			else if (T->data[i].i == T->data[j].i) {
				if (T->data[i].j < T->data[j].j) {
					te2->data[0] = T->data[i];
					T->data[i] = T->data[j];
					T->data[j] = te2->data[0];
				}
			}
		}
	}
	for (int i = 0; i < T->tu; i++) {
		printf("%d %d %d", T->data[i].i, T->data[i].j, T->data[i].e);
		printf("\n");
	}
}
void PrintmultiplyH(TSMatrix* T) {
	printf("The product matrix is:\n");
	int** data2 = (int**)malloc(sizeof(int*) * 100);
	for (int i = 0; i < 100; ++i)
	{
		data2[i] = (int*)malloc(sizeof(int) * 100);
	}
	int cnt = 1;
	for (int i = 0; i <= T->mu; i++) {
		for (int j = 0; j <= T->nu; j++) {
			data2[i][j] = 0;
		}
	}
	for (int i = 0; i < T->tu; i++) {	//在指定位置存放非0元，其余位置都为0
		data2[T->data[i].i][T->data[i].j] = T->data[i].e;
	}
	printf("    ");
	for (int i = 1; i <= T->nu; i++) {
		if (i < 10) {
			printf("   %d", i);
		}
		else if (i < 100) {
			printf("  %d", i);
		}
		else if (i < 1000) {
			printf(" %d", i);
		}
	}
	printf("\n");
	for (int i = 1; i <= T->mu; i++) {
		for (int j = 0; j <= T->nu; j++) {
			if (j == 0) {
				if (cnt < 10) {
					printf("   %d", cnt);
				}
				else if (cnt < 100) {
					printf("  %d", cnt);
				}
				else if (cnt < 1000) {
					printf("  %d", cnt);
				}
				cnt++;
			}
			else {
				if (data2[i][j] >= 0) {
					if (data2[i][j] < 10) {
						printf("   %d", data2[i][j]);
					}
					else if (data2[i][j] < 100) {
						printf("  %d", data2[i][j]);
					}
					else if (data2[i][j] < 1000) {
						printf(" %d", data2[i][j]);
					}
					else  {
						printf("%d", data2[i][j]);
					}
				}
				else {
					if (data2[i][j] > -10) {
						printf("  %d", data2[i][j]);
					}
					else if (data2[i][j] > -100) {
						printf(" %d", data2[i][j]);
					}
					else if (data2[i][j] > -1000) {
						printf("%d", data2[i][j]);
					}
				}
			}
		}
		printf("\n");
	}
}

提交结果：

在这里插入图片描述
代码比较粗糙，可以优化的地方很多，各位大佬可以尽情指点
在这里插入图片描述

c语言稀疏矩阵_C中的稀疏矩阵
culing2941的博客
09-17 1345
c语言稀疏矩阵In this tutorial, we are going to learn about the sparse matrix in C. 在本教程中，我们将学习C语言中的稀疏矩阵。 Before we start let us first discuss what a little bit about two-dimensional arrays. A matrix is r...
7-3 哈夫曼编码 (30 分)
与笑相拥的博客
10-22 5836
7-3 哈夫曼编码 (30 分) 给定一段文字，如果我们统计出字母出现的频率，是可以根据哈夫曼算法给出一套编码，使得用此编码压缩原文可以得到最短的编码总长。然而哈夫曼编码并不是唯一的。例如对字符串"aaaxuaxz"，容易得到字母 ‘a’、‘x’、‘u’、‘z’ 的出现频率对应为 4、2、1、1。我们可以设计编码 {‘a’=0, ‘x’=10, ‘u’=110, ‘z’=111}，也...
数据结构--稀疏矩阵课程设计.doc
02-23
①　存储结构选择三元组存储方式； ②　实现一个稀疏矩阵的转置运算； ③　实现两个稀疏矩阵的加法运算； ④　实现两个稀疏矩阵的减法运算； ⑤　实现两个稀疏矩阵的乘法运算。
c语言实现稀疏矩阵乘法,C语言经典算法 - 稀疏矩阵
weixin_30650955的博客
05-17 770
下面是编程之家 jb51.cc 通过网络收集整理的代码片段。编程之家小编现在分享给大家，也给大家做个参考。说明如果在矩阵中，多数的元素并没有资料，称此矩阵为稀疏矩阵(sparse matrix)， 由于矩阵在程式中常使用二维阵列表示，二维阵列的大小与使用的记忆体空间成正比，如果多数的元素没有资料，则会造成记忆体空间的浪费，为此，必须设计稀疏矩阵的阵列储存方式，利用较少的记忆体空间储存完整的矩阵资讯...
稀疏矩阵的乘法c语言,稀疏矩阵的加减乘法出现问题，求指教，谢谢
weixin_39967812的博客
05-18 79
该楼层疑似违规已被系统折叠隐藏此楼查看此楼#include #include #define MAXSIZE 400typedef struct{int i,j,e;}Triple;typedef struct{Triple data[MAXSIZE+1];int rpos[100];int mu,nu,tu;}RLSMatrix;RLSMatrix create(RLSMatrix A){in...
7-4 稀疏矩阵加法 (20分)_数据结构实验4_羊卓的杨
qq_45800977的博客
11-29 650
7-4 稀疏矩阵加法 (20分) 来都来了点个赞再走呗，一键三连也行，可以点下方链接进入我的bilibili主页转转，也可以关注我的个人公众号~后期公众号会发送一些比较好玩的东西 bilibili：羊卓的杨 公众号：羊卓的杨 ...
【数据结构学习记录13】——稀疏矩阵的表示与运算
康娜喵的原创博客
11-13 6049
稀疏矩阵的表示与运算一.介绍二.实现稀疏矩阵的原理1.稀疏矩阵的顺序存储2.稀疏矩阵的转置T3.求转置的方法4.快速求转置法5.稀疏矩阵加法（减法同理）6.稀疏矩阵的乘法三.稀疏矩阵的代码定义1.稀疏矩阵的元素2.稀疏矩阵的定义3.稀疏矩阵的快速转置4.稀疏矩阵的加减法5.稀疏矩阵的乘法四.代码实现 一.介绍 什么是稀疏矩阵，假设我们有一个矩阵 (以下部分回去重新编辑) [000000025000] \begin{bmatrix} 0 & 0 &0 &0\\ 0 &am
第二周双周赛
qq_66056271的博客
12-12 164
第二次周赛的补题。
数据结构——稀疏矩阵（C语言）
明宇逸风的博客
09-17 3962
矩阵什么是矩阵代码实现三元组以及普通转置矩阵以及三元组的结构体相应功能的函数实现初始化稀疏矩阵矩阵转置链表数据的删除按位置查找数据元素合并两个链表输出链表相应功能集成调用主函数运行截图 什么是矩阵 矩阵，简单的来看，就是二维数组。二维数组本质上是以数组作为数组元素的数组，即“数组的数组”，类型说明符 数组名[常量表达式][常量表达式]。二维数组又称为矩阵，行列数相等的矩阵称为方阵。 代码实现 三元组以及普通转置 矩阵以及三元组的结构体 #include<stdio.h> #include&
稀疏矩阵运算器（C语言实现，代码完整，可读性很好）
06-27
稀疏矩阵是指那些多数元素为零的矩阵。利用“稀疏”特点进行存储和计算 可以大大节省存储空间，提高计算效率。实现一个能进行稀疏矩阵基本运算的运算器。 功能要求： 1. 以“带行逻辑链接信息”的三元组顺序表表示...
稀疏矩阵转化C语言
12-15
C语言稀疏矩阵转换#include int main() { int x,y,i,j; printf("请输入稀疏矩阵的行与列:"); scanf("%d %d",&x,&y); int arr[x][y]; printf("\n请输入稀疏矩阵\n"); for(i=0;i;++i) for(j=0;j;++j) scanf("%d",arr[i...
稀疏矩阵相乘C语言源码
05-16
使用C语言以实现稀疏矩阵之间相乘的简单矩阵运算，亦可以使用于非稀疏矩阵之间的矩阵乘法运算，因为机制是一样的，只是因为稀疏矩阵在算法设计中比较特殊，故而特意加以区分
C语言数据结构两个稀疏矩阵相加
04-30
C语言数据结构之两个稀疏矩阵相加。代码中代码功能描述、输入输出说明和测试输出输入。
C语言实现稀疏矩阵运算，求解线性方程组问题（基于eigen）
yizhiboshanshan的博客
12-06 2894
近期导师让我将一个matlab代码改写成C，其中涉及到大量的矩阵运算和稀疏矩阵运算，经过一段时间的摸索和实践，记录一下这段时间的学习经验 首先由于要基于C语言实现一些矩阵的运算，加减乘除，求逆，以及解线性方程组AX=B之类。 这种矩阵运算自己写的话就有点浪费时间，而且效率肯定不会很高了...故选择eigen库，开源库不用考虑引用问题，且数据结构、函数等相对简单，安装方便，很好上手。 Windows下Eigen + vs配置_wilsonass的博客-CSDN博客 基础的一些矩阵定义及基础矩阵操作可参
稀疏矩阵的初始化及其转置（源代码+截图）
好儿郎~志在四方
04-16 5024
稀疏矩阵：如果在矩阵中，多数的元素为0，通常认为非零元素比上矩阵所有元素的值小于等于0.05时，则称此矩阵为稀疏矩阵（sparse matrix）。
C语言 | Leetcode C语言题解之第542题01矩阵
m0_59237910的博客
11-07 340
C语言 | Leetcode C语言题解之第542题01矩阵
力扣动态规划基础版（矩阵型）
showy0的博客
11-04 1587
矩阵相关的动态规划题目，深入理解
线性代数（第二章：矩阵）
最新发布
kusunoki的博客
11-08 499
归纳了线性代数第二章——矩阵的做题方法与技巧，仅作为复习使用。
费舍尔信息矩阵 & 低秩矩阵 & 渐近正态性
qzhqbb的博客
11-08 676
emo了
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

.别拖至春天.

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值