稀疏矩阵的建立与转置(优选.)
稀疏矩阵三元组快速转置(转poklau123写的很清楚)
稀疏矩阵三元组快速转置(转poklau123写的很清楚)关于稀疏矩阵的快速转置法,⾸先得明⽩其是通过对三元表进⾏转置。
如果误以为是对矩阵进⾏转置,毫⽆疑问就算你想破脑袋也想不出个所以然,别陷⼊死胡同了!对于⼀个三元表,⾏为i,列为j,值为v。
需将其i与j的值对调才能得到新的三元表,但是如果直接进⾏转换,得到的新的三元表的顺序是混乱的,不符合三元表的规则。
所以,课本⾸先介绍了⼀个⽤扫描来转置的算法(这个算法⽐较容易,在这⾥我就不说了),但是这个转置算法的时间复杂度太⾼,于是就有了接下来的快速转置算法。
要你对⼀个三元表进⾏步骤最少的转置,你可能会想,如果知道三元表中每⼀项在转置后的新的三元表中的位置,然后直接放进去,岂不是极⼤的缩⼩了时间复杂度?没错!快速转置法正是基于这种思想⽽设计的。
那么如何知道三元表中某⼀项的位置呢?在课本98页的a.data这个三元表可以看到,j为列号,在转置后即为新的三元表的⾏号,三元表正是按照⾏序进⾏排列的,⽽j=1有2个、j=2有2个、j=3有2个、j=4有1个、j=6有1个。
根据这些数据按照从⼩到⼤排列,j=1的项在新的三元表中应占据第1、2位,j=2的项在新的三元表中应占据第3、4位,j=3的项在新的三元表中应占据第5、6位,j=4应占据第7位,j=6应占据第8位。
接下来就轻松多了,转置的时候直接从第⼀项读起,读取其j值,⽐如课本中a.data这个三元表的第⼀项的j值为2,因为j=2占据第3、4位,所以应该从第三位开始放,接下来如果读取的某⼀项的j值也是2,就放在第4位。
因为j=2的项只有两个,所以第5位绝对不会被j=2的项占据,第5、6项本来就是留给j=3的。
再⽐如当读到j=6的那项时,第8位是留给它的,就可以直接放进第8位了。
这样,读取每⼀项,都能在三元表中找到相应的位置,这就是稀疏矩阵快速转置的原理。
当然,上⾯只是快速转置的原理,要实现它,就要设计算法来实现了。
稀疏矩阵的三元组顺序表存储表示及其转置算法
稀疏矩阵的三元组顺序表存储表示及其转置算法目录1. 引言1.1 背景和意义1.2 结构概述1.3 目的2. 稀疏矩阵的三元组顺序表存储表示2.1 稀疏矩阵的定义与特点2.2 三元组顺序表的数据结构和实现方式2.3 存储表示的优缺点分析3. 稀疏矩阵转置算法3.1 转置操作的意义与应用场景3.2 基于三元组顺序表的转置算法设计思路3.3 转置算法的具体实现步骤与复杂度分析4. 实验与结果分析4.1 实验设置和数据样本介绍4.2 转置算法在不同稀疏矩阵上的性能评估和结果比较4.3 分析结果及启示与讨论5. 结论与展望5.1 结论总结5.2 存在问题及后续工作展望1. 引言1.1 背景和意义稀疏矩阵是一种在实际问题中经常遇到的特殊矩阵结构,其绝大部分元素为零。
与稠密矩阵相比,稀疏矩阵的存储和计算效率更高。
稀疏矩阵可以应用于图像处理、网络分析、线性代数等领域。
三元组顺序表是一种存储稀疏矩阵的数据结构,通过记录非零元素的行索引、列索引和数值,有效地减少了存储空间。
同时,三元组顺序表也提供了便捷的转置操作方式。
因此,深入掌握稀疏矩阵的三元组顺序表存储表示及其转置算法对于提高稀疏矩阵相关问题的解决效率具有重要意义。
1.2 结构概述本文将从两个方面进行论述。
首先,介绍稀疏矩阵的定义与特点,以及三元组顺序表在存储表示中所采用的数据结构和实现方式。
其次,详细描述了基于三元组顺序表的稀疏矩阵转置算法的设计思路、具体实现步骤和复杂度分析。
1.3 目的本文旨在探究稀疏矩阵的三元组顺序表存储表示及其转置算法,在理论层面上深入分析其原理和优劣,并在实验中验证其性能表现。
通过本文的研究,我们希望能够提供一种高效、灵活且易于实现的方法来处理稀疏矩阵,并为进一步的相关应用提供有价值的启示和参考。
2. 稀疏矩阵的三元组顺序表存储表示2.1 稀疏矩阵的定义与特点稀疏矩阵是指在一个二维矩阵中,大部分元素都为0的情况下,只有少数非零元素的情况。
数据结构实验2稀疏矩阵的建立与转置
实验2 稀疏矩阵的建立与转置(一)实验目的掌握特殊矩阵的存储和操作算法。
(二)问题描述实现用三元组保存稀疏矩阵并实现矩阵转置的算法。
(三)实验步骤1. 定义稀疏矩阵的三元组形式的存储结构。
2. 实现三元组矩阵的传统转置算法(pp99 的算法5.1)。
3. 实现三元组矩阵的快速转置算法。
4. 输入矩阵非零元素,测试自己完成的算法。
(四)程序流程图(五)参考代码#include <malloc.h>#include <stdio.h>#define MAXLEN 40typedef struct{ int i, j;int v;}NODE;typedef struct{ int m, n, t;NODE data[MAXLEN];}SPMA TRIX;SPMA TRIX transpose(SPMA TRIX a){/*稀疏矩阵(三元组存储结构)转置算法*/int p, q, col;SPMA TRIX b;b.m=a.n; b.n=a.m; b.t=a.t;if(a.t!=0){q = 1;for (col=1; col<=a.n; col++) //访问b三元组的每一行for (p=1; p<=a.t; p++) //访问a三元组的每一行if(a.data[p].j==col) //如果b三元组的行对应a数组的列,就进行转置{ b.data[q].j=a.data[p].i;b.data[q].i=a.data[p].j;b.data[q].v=a.data[p].v;q++;}}return b;}void printmatrix(SPMA TRIX c){/*稀疏矩阵(三元组存储结构)显示*/int n,i;n=c.t;for(i=1;i<=n;i++)printf("[%d]行号=%d 列号=%d 元素值=%d\n",i,c.data[i].i,c.data[i].j,c.data[i].v);}void main(){ SPMA TRIX a;SPMA TRIX b;int i,j,r,c,t,n;n=1;printf("\n\n输入矩阵行号数: ");scanf("%d",&r);printf("\n\n输入矩阵列号数: ");scanf("%d",&c);a.m=r; a.n=c;printf("\n\n");for(i=0;i<r;i++) /*输入矩阵元素值*/for(j=0;j<c;j++){printf("输入元素[%d,%d]值: ",i+1,j+1);scanf("%d",&t);if(t!=0) {a.data[n].i=i+1; /*非零元素存入稀疏矩阵三元组存储结构中*/a.data[n].j=j+1; a.data[n].v=t; n=n+1;}}n=n-1; a.t=n; /*a.t中为稀疏矩阵非零元素个数*/printf("\n\n稀疏矩阵三元组表示: \n\n");printmatrix(a); /*稀疏矩阵(三元组存储结构)转置*/b=transpose(a);printf("\n\n转置后稀疏矩阵三元组表示: \n\n");printmatrix(b);printf("\n\n");}(六)运行结果(七)心得体会掌握了特殊矩阵的存储和操作原理,编写了用三元组保存稀疏矩阵并实现矩阵转置的算法。
稀疏矩阵的表示和转置
实验2稀疏矩阵的表示和转置实验人:杜国胜学号:Xb14680103时间:11.91、实验目的1.掌握稀疏矩阵的三元组顺序表存储结构2.掌握稀疏矩阵的转置算法。
2、实验内容采用三元组表存储表示,求稀疏矩阵M的转置矩阵T。
(算法5.1)3、实验步骤:1.构建稀疏矩阵M。
2.求稀疏矩阵M的转置矩阵T。
3.输出稀疏矩阵M和稀疏矩阵T。
4、算法说明首先要创建稀疏矩阵和三元组顺序表,定义mu,mu,tu分别表示矩阵的行列数和非零元个数。
在进行稀疏矩阵的转置时要做到1.将矩阵的行列值相互交换2.将每个三元组的I,j相互调换3.重排三元组之间的次序5、测试结果6、分析讨论在此次程序中转置的方法称为快速转置,在转置前,应先求的M的每一列中非零元的个数,进而求得每一列的第一个非零元的位置7、附录:源代码#include<stdio.h>#define MAXSIZE 100typedef struct{int i,j;int e;}Triple;typedef struct{Triple data[MAXSIZE+1];int mu,nu,tu;}TSMatrix;//创建稀疏矩阵Mvoid CreateSMatrix (TSMatrix *M){int i,m,n,e,k;printf("输入矩阵M的行数、列数、非零元的个数(中间用逗号隔开):");scanf("%d,%d,%d",&(*M).mu,&(*M).nu,&(*M).tu);(*M).data[0].i=0;printf("\n");for(i=1;i<=(*M).tu;i++){do{printf("输入第%d个非零元素所在的行(1~%d)列(1~%d)值以及该数值:",i,(*M).mu,(*M).nu);scanf("%d,%d,%d",&m,&n,&e);k=0;if(m<1||m>(*M).mu||n<1||n>(*M).nu)k=1;if(m<(*M).data[i-1].i||m==(*M).data[i-1].i&&n<(*M).data[i-1].j)k=1;}while(k);(*M).data[i].i=m;(*M).data[i].j=n;(*M).data[i].e=e;}printf("\n");}//输出稀疏矩阵Mvoid PrintSMatrix(TSMatrix M){int i;printf("**************************************\n");for(i=1;i<=M.tu;i++)printf("%2d%4d%8d\n",M.data[i].i,M.data[i].j,M.data[i].e); printf("**************************************\n");printf("\n");}//求稀疏矩阵M的转置矩阵Tvoid TransposeSMatrix(TSMatrix M,TSMatrix *T){int p,q,col;(*T).mu=M.nu;(*T).nu=M.mu;(*T).tu=M.tu;if((*T).tu){q=1;for(col=1;col<=M.nu;++col)for(p=1;p<=M.tu;++p)if(M.data[p].j==col){(*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 print(TSMatrix A){int k=1,a,b;int M[MAXSIZE][MAXSIZE];printf("非零元素所对应的位置:\n");printf("**************************************\n"); for(a=0;a<A.mu;a++){for(b=0;b<A.nu;b++)M[a][b]=0;}while(k<=A.tu){M[A.data[k].i-1][A.data[k].j-1]=A.data[k].e;k++;}for(a=0;a<A.mu;a++){printf(" | ");for(b=0;b<A.nu;b++)printf("%d ",M[a][b]);printf(" | \n");}printf("**************************************\n"); printf("\n");}//主函数int main(){TSMatrix M,T;printf("创建矩阵M:");CreateSMatrix(&M);printf("矩阵M的三元组表为:\n");PrintSMatrix(M);print(M);TransposeSMatrix(M,&T);printf("稀疏矩阵M的转换矩阵T的三元组表为:\n");PrintSMatrix(T);print(T);printf("\n\n");getchar();return 0;}。
稀疏矩阵的快速转置算法
稀疏矩阵的快速转置算法
稀疏矩阵的快速转置算法可以使用压缩存储的方式来实现。
稀疏矩阵通常包含很多零元素,因此压缩存储可以极大地减少存储空间和计算时间。
压缩存储可以使用两个数组来表示稀疏矩阵,一个存储非零元素的值,另一个存储非零元素在原始矩阵中的行列索引。
假设原始矩阵的行数为m,列数为n,稀疏矩阵中非零元素的个数为k。
转置算法的步骤如下:
1. 创建一个新的稀疏矩阵,行数为n,列数为m,非零元素个数为k。
2. 初始化一个长度为n的数组col_ptr,用于记录每列的第一个非零元素在转置矩阵中的索引。
3. 通过遍历原始稀疏矩阵的每个非零元素,将其值存储到转置矩阵的非零元素数组中,并根据其列索引更新col_ptr数组。
4. 根据col_ptr数组,计算每列非零元素在转置矩阵非零元素数组中的起始位置,并将其存储到col_ptr数组中。
5. 返回转置矩阵。
这个算法的时间复杂度为O(k),空间复杂度为O(n+m+k)。
通过压缩存储和利用非零元素在矩阵中的位置信息,这种算法可以高效地实现稀疏矩阵的快速转置。
稀疏矩阵的相关操作
稀疏矩阵的相关操作稀疏矩阵是指在一个矩阵中,大部分元素为0的矩阵。
由于大部分元素为0,而非零元素相对较少,稀疏矩阵的存储和处理具有一定的特殊性。
在实际应用中,经常需要对稀疏矩阵进行各种操作,如创建、存储、加法操作等。
本文将从这些方面详细介绍稀疏矩阵的相关操作。
首先,创建稀疏矩阵需要考虑两个关键因素:矩阵的大小和矩阵的稀疏性。
对于稀疏矩阵的大小,一般可以使用行数和列数来描述。
而对于稀疏矩阵的稀疏性,可以使用一个矩阵的非零元素个数与总元素个数的比值来衡量,一般使用稀疏度来表示,即非零元素个数与总元素个数的比值。
创建稀疏矩阵的方法有多种,下面介绍两种常见的方法。
1.压缩矩阵存储法:该方法将稀疏矩阵的非零元素和对应的行列坐标存储在一个矩阵中。
其中,矩阵的每一行存储一个非零元素的值、行和列坐标。
这种方法虽然节约了存储空间,但是在进行矩阵操作时,需要通过遍历矩阵找到对应的非零元素,因此操作效率较低。
2.链表存储法:该方法将稀疏矩阵的非零元素和对应的行列坐标存储在一个链表中。
链表的每个节点包含一个非零元素的值、行和列坐标,以及下一个非零元素的指针。
这种方法在插入和删除操作时比较方便,并且节约了存储空间。
但是,链表存储法在进行矩阵操作时,也需要通过遍历链表找到对应的非零元素,因此操作效率较低。
除了创建稀疏矩阵,还需要进行其他各种操作,如稀疏矩阵的加法、乘法、转置等。
稀疏矩阵的乘法操作较为复杂。
对于两个稀疏矩阵相乘,需要根据矩阵乘法的定义,将一个矩阵的行与另一个矩阵的列进行乘法运算,然后将结果相加得到最终的乘积矩阵。
由于稀疏矩阵的特殊性,可以采用稀疏矩阵乘法算法进行计算,提高乘法操作的效率。
1.三元组转置法:该方法将稀疏矩阵的非零元素和对应的行列坐标存储在三个数组中,分别是非零元素数组、行坐标数组和列坐标数组。
将这三个数组的元素进行转置,并重新组合成转置后的稀疏矩阵。
2.链表转置法:该方法将稀疏矩阵的非零元素和对应的行列坐标存储在链表中。
稀疏矩阵三元组实现矩阵转置算法实验报告
稀疏矩阵三元组实现矩阵转置算法实验报告实验三稀疏矩阵的三元组表示实现矩阵转置算法学院专业班学号姓名一.实习目的1.掌握稀疏矩阵的三元组顺序表存储表示;2.掌握稀疏矩阵三元组表示的传统转置算法的实现;3.掌握稀疏矩阵三元组表示的快速转置算法的实现;二.实习内容1.稀疏矩阵的按三元组形式输入,即按行序输入非零元的行号、列号、值,实现传统转置算法,输出按通常的阵列形式输出。
2.稀疏矩阵的按三元组形式输入,即按行序输入非零元的行号、列号、值,实现快速转置算法,输出按通常的阵列形式输出。
三.实验步骤1.三元组的定义#define MAX_SIZE 100 // 非零元个数的最大值struct Triple{int i,j; // 行下标,列下标ElemType e; // 非零元素值};struct TSMatrix{struct Triple data[MAX_SIZE+1]; // 非零元三元组表,data[0]未用int mu,nu,tu; // 矩阵的行数、列数和非零元个数};2.创建稀疏矩阵M (按三元组形式输入,即按行序输入非零元的行号、列号、值)3. 编写三元组传统转置函数。
4. 编写三元组快速转置函数。
4. .主函数(1)程序代码#include "stdio.h"#include "stdlib.h"#define MAX_SIZE 100 // 非零元个数的最大值typedef int ElemType;struct Triple{int i,j; // 行下标,列下标ElemType e; // 非零元素值};struct TSMatrix{struct Triple data[MAX_SIZE+1]; // 非零元三元组表,data[0]未用int mu,nu,tu; // 矩阵的行数、列数和非零元个数};int CreateSMatrix(TSMatrix &M){ // 创建稀疏矩阵Mint i,m,n;ElemType e;int k;printf("请输入矩阵的行数,列数,非零元素数:");scanf("%d,%d,%d",&M.mu,&M.nu,&M.tu);if(M.tu>MAX_SIZE)return -1;M.data[0].i=0; // 为以下比较顺序做准备for(i=1;i<=M.tu;i++){do{printf("请按行序顺序输入第%d个非零元素所在的行(1~%d),列(1~%d),元素值:",i,M.mu,M.nu);scanf("%d,%d,%d",&m,&n,&e);//输入非零元的行号、列号、元素值k=0;if(m<1||m>M.mu||n<1||n>M.nu)// 行或列超出范围k=1;if(m<M.data[i-1].i||m==M.data[i-1].i&&n<=M.d ata[i-1].j) // 行或列的顺序有错k=1;}while(k);M.data[i].i =m; // 将m,n,e 填入MM.data[i].j =n;M.data[i].e =e;}return 1;}void PrintSMatrix(TSMatrix M){ // 按矩阵形式输出Mint i,j,k=1;Triple *p=M.data;p++; // p指向第1个非零元素for(i=1;i<=M.mu;i++){for(j=1;j<=M.nu;j++)if(k<=M.tu&&p->i==i&&p->j==j)// p指向非零元,且p所指元素为当前处理元素{printf("%3d",p->e); // 输出p所指元素的值p++; // p指向下一个元素k++; // 计数器+1}else // p所指元素不是当前处理元素printf("%3d",0); // 输出0printf("\n");}}void TransposeSMatrix(TSMatrix M,TSMatrix &T){ // 求稀疏矩阵M的转置矩阵T。
稀疏矩阵转置算法的实现
稀疏矩阵转置算法的实现稀疏矩阵转置算法是一种十分重要的算法,它可以将一个大型的稀疏矩阵转换成另一个表述形式便于计算和存储。
在本文中,我们将讨论如何实现这样的算法。
首先,我们需要了解稀疏矩阵是什么。
稀疏矩阵是指在某种意义下,其中大多数值都为零的矩阵。
在实际应用中,这种矩阵十分常见。
由于其中大多数值都为零,因此,我们可以省略这些零值,只存储非零值。
这样,矩阵的存储空间就可以被大大减小。
那么,稀疏矩阵转置算法是什么?我们可以将转置矩阵定义为:把矩阵A的行换成列,列换成行所得到的矩阵。
在这个过程中,非零元素的位置会相应发生变化。
因此,在转置后的矩阵中,每个非零元素的行和列会互换。
接下来,我们来讨论一下稀疏矩阵转置算法的实现。
在实际应用中,我们通常使用三元组格式存储稀疏矩阵,即以行、列和非零元素为基本元素进行存储。
对于一个$m*n$的稀疏矩阵A,我们可以用一个数组A[0...t]来存储其中的非零元素。
数组中的每个元素包含三个值:行号i,列号j以及该位置上的数据A(i,j)。
其中,t表示非零元素的个数。
那么,如何实现矩阵的转置呢?算法的基本思路是:首先,我们需要遍历稀疏矩阵A中所有的元素,找到其中的每个非零元素;其次,我们将该非零元素从A中删除,并将它添加到新的稀疏矩阵B中。
在添加的过程中,我们需要将该元素的行和列互换,以满足转置的要求。
下面,我们来看一下矩阵转置算法的具体实现。
为了简洁起见,我们假设我们已经将稀疏矩阵A存储在三元组格式中,并且已经初始化了新的稀疏矩阵B。
具体实现如下:```for(k=0; k<t; k++){ // 遍历稀疏矩阵A中的所有元素i=A[k].row; // 获取当前元素的行j=A[k].col; // 获取当前元素的列x=A[k].value; // 获取当前元素的值B[k].row=j; // 将当前元素的行赋值为列B[k].col=i; // 将当前元素的列赋值为行B[k].value=x; // 将当前元素的值保持不变}```在这段代码中,我们首先使用for循环遍历了数组A中的所有元素。
稀疏矩阵快速转置算法
稀疏矩阵快速转置算法
稀疏矩阵快速转置算法是一种用于高效地将稀疏矩阵进行转置的算法。
稀疏矩阵是指其中大部分元素为零的矩阵。
下面是一种常见的稀疏矩阵快速转置算法,称为CRS(Compressed Row Storage)格式:
1. 首先,遍历原始矩阵,统计每列非零元素的个数,并记录每个非零元素在转置后矩阵中的位置。
2. 创建一个长度为列数的数组col_ptr,用于记录每一列非零元素在转置后矩阵中的起始位置。
3. 初始化col_ptr数组,使得col_ptr[i]表示第i列在转置后矩阵中的起始位置,初始值为0。
4. 再次遍历原始矩阵,将每个非零元素按照其在转置后矩阵中的位置放入对应的位置。
对于原始矩阵中的每个非零元素A[i][j],找到其在转置后矩阵中的位置,即col_ptr[j] + 1,将该元素放入转置后矩阵的该位置。
更新col_ptr[j],使其加1,以便下一个非零元素能够放入正确的位置。
5. 完成转置后,得到转置后的稀疏矩阵。
这种算法的时间复杂度为O(n + nz),其中n是原始矩阵的列数,nz是原始矩阵的非零元素个数。
该算法通过压缩存储和避免无效操作,能够高效地进行稀疏矩阵的转置。
1。
MATLAB中的稀疏矩阵处理技巧
MATLAB中的稀疏矩阵处理技巧一、引言稀疏矩阵在实际的科学和工程问题中经常出现。
相较于密集矩阵,稀疏矩阵具有更高的存储效率和计算效率。
MATLAB作为一种强大的科学计算软件,提供了丰富的稀疏矩阵处理函数和技巧。
本文将介绍一些MATLAB中处理稀疏矩阵的技巧,以及它们在实际问题中的应用。
二、稀疏矩阵的表示稀疏矩阵是指矩阵中绝大多数元素为0,仅有少量非零元素的特殊矩阵。
在MATLAB中,稀疏矩阵的表示可以使用两种方式:完全稀疏表示和压缩稀疏表示。
完全稀疏表示是指将矩阵的每个元素都存储起来,包括0元素。
这种表示方式的好处是可以直接使用矩阵的标准运算,但是会占用大量的存储空间,效率较低。
压缩稀疏表示是指只存储矩阵中非零元素及其对应的行列索引。
这种表示方式可以节省存储空间,提高计算效率。
在MATLAB中,可以使用稀疏矩阵函数sparse()将完全稀疏矩阵转换为压缩稀疏表示。
三、稀疏矩阵的创建和操作1. 创建稀疏矩阵在MATLAB中,可以使用sparse()函数创建一个稀疏矩阵,该函数的参数包括矩阵的行数、列数和非零元素的位置及值。
例如,下面的代码创建了一个3x3的稀疏矩阵:```matlabA = sparse([1 1 2 2 3],[1 2 2 3 1],[1 2 3 4 5],3,3);```2. 稀疏矩阵的基本操作稀疏矩阵在MATLAB中的基本运算和操作与普通矩阵相似,包括加减乘除、转置、逆矩阵等。
例如,可以使用"+"运算符对稀疏矩阵进行加法运算,使用"*"运算符进行矩阵乘法运算。
另外,稀疏矩阵还可以进行像素级的操作,例如在图像处理中,可以将稀疏矩阵的非零元素设置为像素的灰度值,实现图像的旋转、缩放等操作。
四、稀疏矩阵的存储和压缩在MATLAB中,稀疏矩阵的存储和压缩是一项重要的技巧。
当矩阵的维数较大时,完全稀疏表示会极大地占用存储空间,不仅浪费了内存,也会影响计算速度。
稀疏矩阵基本操作 实验报告
稀疏矩阵基本操作实验报告一、实验内容稀疏矩阵的压缩储存结构,以及稀疏矩阵的三元组表表示方法下的转置、相加、相乘等算法二、实验目的1.熟悉数组、矩阵的定义和基本操作2.熟悉稀疏矩阵的储存方式和基本运算3.理解稀疏矩阵的三元组表类型定义,掌握稀疏矩阵的输入、输出和转置算法三、实验原理1.使用三元组储存矩阵中的非零元素(三元组分别储存非零元素的行下标,列下标和元素值)。
除了三元组表本身,储存一个稀疏矩阵还需要额外的三个变量,分别储存矩阵的非零元个数,矩阵的行数和矩阵的列数。
2.稀疏矩阵的创建算法:第一步:根据矩阵创建一个二维数组,表示原始矩阵第二步:取出二维数组中的元素(从第一个元素开始取),判断取出元素是否为非零元素,如果为非零元素,把该非零元素的数值以及行下标和列下表储存到三元数组表里,否则取出下一个元素,重复该步骤。
第三步:重复第二步,知道二维数组中所有的元素已经取出。
3.稀疏矩阵倒置算法:第一步:判断进行倒置的矩阵是否为空矩阵,如果是,则直接返回错误信息。
第二步:计算要倒置的矩阵每列非零元素的数量,存入到num数组(其中num[i] 代表矩阵中第i列非零元素的个数)。
以及倒置后矩阵每行首非零元的位置,存入cpot 数组中(其中cpot表示倒置后矩阵每行非零元的位置,对应表示原矩阵每列中第一个非零元的位置)。
第三步:确定倒置后矩阵的行数和列数。
第四步:取出表示要导致矩阵中三元组表元素{e, I, j}(第一次取出第一个,依次取出下一个元素),从第二步cpot数组中确定该元素倒置后存放的位置(cpot[j]),把该元素的行下标和列下标倒置以后放入新表的指定位置中。
cpot[j] 变量加一。
第五步:重复第四步,直到三元组表中所有的元素都完成倒置。
第六步:把完成倒置运算的三元组表输出。
4.稀疏矩阵加法算法:第一步:检查相加两个矩阵的行数和列数是否相同,如果相同,则进入第二步,否则输出错误信息。
第二步:定义变量i和j,用于控制三元组表的遍历。
稀疏矩阵的快速转置算法(c语言)详解
稀疏矩阵的快速转置算法(C语言)详解稀疏矩阵是指大部分元素为零的矩阵,只有少数元素为非零的矩阵。
在实际的计算机科学和工程应用中,稀疏矩阵经常出现,比如在图形图像处理、科学计算和数据分析等领域。
而稀疏矩阵的快速转置算法是针对稀疏矩阵的一种重要算法,它可以有效地将稀疏矩阵进行转置,从而方便后续的计算和操作。
快速转置算法的实现是计算机科学中一个经典的问题,对于稀疏矩阵来说更是如此。
在本文中,我们将从深度和广度两个方面对稀疏矩阵的快速转置算法进行全面评估,探讨其原理和实现细节,并对其进行详细解析。
让我们简要了解一下稀疏矩阵的结构和特点。
稀疏矩阵通常由三个部分组成:行数组、列数组和值数组。
行数组存储非零元素所在的行号,列数组存储非零元素所在的列号,而值数组则存储非零元素的值。
由于稀疏矩阵的特殊性,传统的矩阵转置算法并不适用于稀疏矩阵,因此需要设计一种特殊的快速转置算法来处理稀疏矩阵。
在对快速转置算法进行详细解析之前,让我们先来看一下转置操作的定义。
对于一个矩阵A,其转置矩阵记为A^T,即A的行与列互换。
在稀疏矩阵的转置操作中,我们需要将原始矩阵中的非零元素按照列索引进行重新排列,同时保持其在矩阵中的相对位置不变。
实现稀疏矩阵的快速转置算法涉及到矩阵的数据结构和算法设计方面的知识。
传统的方法是通过对每个非零元素进行遍历,并将其插入到新矩阵的相应位置中,但这种方法的时间复杂度较高。
而快速转置算法通过巧妙的数据结构设计和算法优化,可以在更短的时间内完成转置操作,提高了算法的效率。
在C语言中实现稀疏矩阵的快速转置算法需要考虑到内存管理、指针操作和数据结构的设计等方面。
通常情况下,可以使用链表等数据结构来表示稀疏矩阵,同时利用指针进行快速的遍历和操作。
在实际的编程过程中,还需要注意对内存的合理分配和释放,以避免内存泄漏和溢出的问题。
为了更好地理解稀疏矩阵的快速转置算法,我们可以通过具体的代码实现来加深对算法原理的理解。
matlab 稀疏矩阵运算
matlab 稀疏矩阵运算Matlab是一款强大的数值计算软件,其中包含了丰富的工具箱,用以进行各种矩阵运算。
本文将重点介绍Matlab中的稀疏矩阵运算。
稀疏矩阵是指矩阵中大部分元素为零的矩阵。
在实际问题中,往往会遇到大规模的稀疏矩阵,例如图像处理、网络分析等领域。
由于稀疏矩阵中大部分元素为零,因此存储和计算稀疏矩阵的效率远远高于稠密矩阵。
在Matlab中,我们可以使用稀疏矩阵来存储和处理稀疏矩阵。
Matlab提供了专门的稀疏矩阵存储格式,可以大大提高稀疏矩阵的存储和计算效率。
下面我们将介绍一些常用的稀疏矩阵运算函数。
1. 创建稀疏矩阵我们可以使用sparse函数来创建稀疏矩阵。
该函数的基本用法为:```matlabS = sparse(i, j, v, m, n)```其中,i和j分别表示非零元素所在的行和列的索引,v表示非零元素的值,m和n分别表示矩阵的行数和列数。
例如,我们可以创建一个3行4列的稀疏矩阵S:```matlabS = sparse([1 2 3], [2 3 4], [1 2 3], 3, 4)```2. 稀疏矩阵的加法和减法Matlab提供了两个函数sparse和spdiags来进行稀疏矩阵的加法和减法运算。
例如,我们可以创建两个稀疏矩阵S1和S2,并进行加法和减法运算:```matlabS1 = sparse([1 2 3], [2 3 4], [1 2 3], 3, 4)S2 = sparse([1 2 3], [2 3 4], [4 5 6], 3, 4)S_add = S1 + S2S_sub = S1 - S2```3. 稀疏矩阵的乘法稀疏矩阵的乘法是一个重要的运算,可以用于解决线性方程组、最小二乘问题等。
在Matlab中,我们可以使用*运算符来进行稀疏矩阵的乘法运算。
例如,我们可以创建两个稀疏矩阵S1和S2,并进行乘法运算:```matlabS1 = sparse([1 2 3], [2 3 4], [1 2 3], 3, 4)S2 = sparse([1 2 3], [2 3 4], [4 5 6], 4, 5)S_mul = S1 * S2```4. 稀疏矩阵的转置稀疏矩阵的转置是指将矩阵的行和列对调。
三元组表示稀疏矩阵的转置(一般算法和快速算法)
一、设计要求1.1 问题描述稀疏矩阵是指那些多数元素为零的矩阵。
利用稀疏特点进行存储和计算可以大大节省存储空间,提高计算效率。
求一个稀疏矩阵A的转置矩阵B。
1.2需求分析(1)以“带行逻辑链接信息”的三元组顺序表表示稀疏矩阵,实现稀疏矩阵的转置运算。
(2)稀疏矩阵的输入形式采用三元组表示,运算结果则以通常的阵列形式列出。
(3)首先提示用户输入矩阵的行数、列数、非零元个数,再采用三元组表示方法输入矩阵,然后进行转置运算,该系统可以采用两种方法,一种为一般算法,另一种为快速转置算法。
(4)程序需要给出菜单项,用户按照菜单提示进行相应的操作。
二、概要设计2.1存储结构设计采用“带行逻辑链接信息”的三元组顺序表表示矩阵的存储结构。
三元组定义为:typedef struct{int i;//非零元的行下标int j;//非零元的列下标ElemType e; //非零元素值}Triple;矩阵定义为:Typedef struct{Triple data[MAXSIZE+1]; //非零元三元组表int rpos[MAXRC+1]; //各行第一个非零元的位置表int mu,nu,tu; //矩阵的行数、列数和非零元个数}RLSMatrix;例如有矩阵A,它与其三元组表的对应关系如图2.2 系统功能设计本系统通过菜单提示用户首先选择稀疏矩阵转置方法,然后提示用户采用三元组表示法输入数据创建一个稀疏矩阵,再进行矩阵的转置操作,并以通常的阵列形式输出结果。
主要实现以下功能。
(1)创建稀疏矩阵。
采用带行逻辑连接信息的三元组表表示法,提示用户输入矩阵的行数、列数、非零元个数以及各非零元所在的行、列、值。
(2)矩阵转置。
<1>采用一般算法进行矩阵的转置操作,再以阵列形式输出转置矩阵B。
<2>采用快速转置的方法完成此操作,并以阵列形式输出转置矩阵B。
三、模块设计3.1 模块设计程序包括两个模块:主程序模块、矩阵运算模块。
稀疏矩阵转置+快速转置
稀疏矩阵转置+快速转置稀疏矩阵转置Description稀疏矩阵的存储不宜⽤⼆维数组存储每个元素,那样的话会浪费很多的存储空间。
所以可以使⽤⼀个⼀维数组存储其中的⾮零元素。
这个⼀维数组的元素类型是⼀个三元组,由⾮零元素在该稀疏矩阵中的位置(⾏号和列号对)以及该元组的值构成。
矩阵转置就是将矩阵⾏和列上的元素对换。
现在就请你对⼀个稀疏矩阵进⾏转置。
以下是稀疏矩阵转置的算法描述:图:稀疏矩阵转置的算法描述Input输⼊的第⼀⾏是两个整数r和c(r*c <= 12500),分别表⽰⼀个包含很多0的稀疏矩阵的⾏数和列数。
接下来有r⾏,每⾏有c个整数,表⽰这个稀疏矩阵的各个元素。
Output输出c⾏,每⾏有r个整数,每个整数后跟⼀个空格。
该结果为输⼊稀疏矩阵的转置矩阵。
Sample Input6 70 12 9 0 0 0 00 0 0 0 0 0 0-3 0 0 0 0 14 00 0 24 0 0 0 00 18 0 0 0 0 015 0 0 -7 0 0 0Sample Output0 0 -3 0 0 1512 0 0 0 18 09 0 0 24 0 00 0 0 0 0 -70 0 0 0 0 00 0 14 0 0 00 0 0 0 0 0HINT提⽰:严⽼师纸质书中⽤union类型来表⽰稀疏矩阵类型,这是有问题的,应该使⽤struct来表⽰该类型。
注意理解为什么转置算法中,以列从⼩到⼤来进⾏转置。
实际上只需⼀个循环就能够完成转置⽽不需将列从⼩到⼤来处理,转置后的矩阵虽然是正确的但却乱掉了,以⾄于在各种处理中会增加复杂。
(其实就本题⽽⾔,如果不以列从⼩到⼤处理将导致输出困难,输出的复杂度增加)总结:矩阵是⼀个应⽤很⼴泛的⼯具和课题。
看看《⿊客帝国》就知道了。
现在初步给⼤家介绍矩阵的操作,以后有机会还会详细讨论矩阵的。
1 #include <stdio.h>2 #include <string.h>3 #include <iostream>4 #include <string>5 #include <math.h>6 #include <algorithm>7 #include <vector>8 #include <stack>9 #include <queue>10 #include <set>11 #include <map>12 #include <math.h>13const int INF=0x3f3f3f3f;14 typedef long long LL;15const int mod=1e9+7;16const int maxn=1e4+10;17using namespace std;1819 typedef struct20 {21int row;22int col;23int val;24 }Triple;2526 typedef struct27 {28 Triple date[maxn];29int rows;30int cols;31int nums;32 }TSMatrix;3334void TransposeTSMatrix(TSMatrix *A,TSMatrix *B)35 {36 B->rows=A->cols;37 B->cols=A->rows;38 B->nums=A->nums;39if(B->nums > 0)40 {41int cnt=0;42for(int i=1;i<=A->cols;i++)43 {44for(int j=1;j<=A->nums;j++)45 {46if(A->date[j].col==i)47 {48 cnt++;49 B->date[cnt].row=A->date[j].col;50 B->date[cnt].col=A->date[j].row;51 B->date[cnt].val=A->date[j].val;52 }53 }54if(cnt == B->nums)55break;56 }57 }58return ;59 }6061int main()62 {63 TSMatrix A,B;64 scanf("%d %d",&A.rows,&A.cols);65 A.nums=0;66for(int i=1;i<=A.rows;i++)67 {68for(int j=1;j<=A.cols;j++)69 {70int x;71 scanf("%d",&x);72if(x)73 {74 A.nums++;75 A.date[A.nums].row=i;76 A.date[A.nums].col=j;77 A.date[A.nums].val=x;78 }79 }80 }81 TransposeTSMatrix(&A,&B);82int cnt=1;83for(int i=1;i<=B.rows;i++)84 {85for(int j=1;j<=B.cols;j++)86 {87int a,b;88 a=B.date[cnt].row;89 b=B.date[cnt].col;90if(a==i&&b==j)91 {92 printf("%d ",B.date[cnt].val);93 cnt++;94 }95else96 printf("%d ",0);97 }98 printf("\n");99 }100return0;101 }稀疏矩阵快速转置Description稀疏矩阵的存储不宜⽤⼆维数组存储每个元素,那样的话会浪费很多的存储空间。
稀疏矩阵加法和转置c语言
稀疏矩阵加法和转置c语言稀疏矩阵是指矩阵中大部分元素为零的矩阵。
在实际应用中,很多矩阵都是稀疏的,例如图像处理、网络分析等领域。
为了节省存储空间和提高运算效率,我们需要使用特殊的方法来处理稀疏矩阵。
在C语言中,实现稀疏矩阵加法的方法有很多种,我们这里介绍一种常见的方法。
假设我们有两个稀疏矩阵A和B,它们的大小都是m 行n列。
我们的目标是计算它们的和矩阵C。
我们需要定义一个结构体来表示稀疏矩阵的非零元素。
这个结构体包含三个成员变量:行号row、列号column和元素值value。
我们可以使用一个数组来存储所有的非零元素。
接下来,我们需要编写一个函数来实现稀疏矩阵加法。
这个函数接受两个稀疏矩阵A和B作为参数,返回它们的和矩阵C。
函数的实现过程如下:1. 遍历稀疏矩阵A的所有非零元素,将它们加入和矩阵C中。
2. 遍历稀疏矩阵B的所有非零元素,将它们加入和矩阵C中。
3. 如果两个非零元素的行号和列号相同,我们需要将它们的值相加并存储到和矩阵C中。
在实际编写代码时,我们可以使用两个指针来分别指向稀疏矩阵A 和B的非零元素,这样可以提高遍历的效率。
除了稀疏矩阵加法,转置也是处理稀疏矩阵的常见操作之一。
在转置操作中,我们需要将矩阵的行与列互换,即将矩阵的第i行转置为第i列。
同样地,我们可以使用一个结构体来表示稀疏矩阵的非零元素。
在转置操作中,我们只需要将每个非零元素的行号和列号互换即可。
具体实现过程如下:1. 遍历稀疏矩阵的所有非零元素。
2. 将每个非零元素的行号和列号互换。
与稀疏矩阵加法类似,我们可以使用指针来提高遍历的效率。
总结起来,稀疏矩阵加法和转置是处理稀疏矩阵的两个常见操作。
在C语言中,我们可以使用结构体和指针来实现这两个操作。
通过合理的算法设计和代码实现,我们可以高效地处理稀疏矩阵,节省存储空间和提高运算效率。
希望本文对读者理解稀疏矩阵加法和转置在C语言中的实现有所帮助。
对稀疏矩阵结构的操作
对稀疏矩阵结构的操作稀疏矩阵是一种特殊的矩阵结构,其大部分元素为0,只有少部分非零元素。
由于稀疏矩阵的特殊性,对其进行操作时需要采用特定的方法和算法。
本文将介绍几种常见的对稀疏矩阵进行操作的方法。
一、稀疏矩阵的存储方式稀疏矩阵的存储方式有多种,常见的有三元组表示法和压缩存储方式。
三元组表示法是将非零元素的行、列和值分别存储在三个数组中,这种存储方式简单直观,但是对于大规模稀疏矩阵来说,空间占用较大。
压缩存储方式则是将稀疏矩阵按行或按列进行压缩存储,只存储非零元素的位置和值,可以大大减小空间占用。
二、稀疏矩阵的加法和减法对于稀疏矩阵的加法和减法,可以采用三元组表示法或压缩存储方式。
首先需要将两个矩阵转换为相同的存储方式,然后按照矩阵的行列进行遍历,将对应位置的元素进行加法或减法操作。
在遍历过程中,需要注意处理非零元素的情况,可以采用稀疏矩阵的存储结构进行判断和处理。
三、稀疏矩阵的乘法稀疏矩阵的乘法是一种复杂的运算,涉及到矩阵的行列遍历和乘法操作。
对于两个稀疏矩阵的乘法,可以采用三元组表示法或压缩存储方式。
首先需要将两个矩阵转换为相同的存储方式,然后按照矩阵的行列进行遍历,对于每个非零元素,需要找到对应位置的元素进行乘法操作,并将结果累加。
在遍历过程中,可以采用稀疏矩阵的存储结构进行优化,减少不必要的运算。
四、稀疏矩阵的转置稀疏矩阵的转置是将矩阵的行和列进行互换,对于稀疏矩阵,可以采用三元组表示法或压缩存储方式进行转置。
对于三元组表示法,只需要将行和列进行互换即可;对于压缩存储方式,只需要将行和列的索引进行互换,并按照转置后的行列顺序重新排列非零元素。
五、稀疏矩阵的求逆稀疏矩阵的求逆是一种复杂的运算,需要借助于线性代数的知识和算法。
对于稀疏矩阵的求逆,可以采用LU分解、LDU分解或Cholesky分解等方法。
这些方法可以将稀疏矩阵分解为三个矩阵的乘积,然后再求解逆矩阵。
在求解过程中,需要注意处理稀疏矩阵的特殊结构,以提高求解的效率。
稀疏矩阵的建立与转置(优选.)
实验2 稀疏矩阵的建立与转置一、实验目的掌握特殊矩阵的存储和操作算法。
二、实验内容及问题描述实现用三元组保存稀疏矩阵并实现矩阵转置的算法。
三、实验步骤1. 定义稀疏矩阵的三元组形式的存储结构。
2. 实现三元组矩阵的传统转置算法。
3. 实现三元组矩阵的快速转置算法。
4. 输入矩阵非零元素,测试自己完成的算法。
四、程序流程图五、概要设计矩阵是很多的科学与工程计算中研究的数学对象。
在此,我们感兴趣的是,从数学结构这门学科着眼,如何存储矩阵的元从而使矩阵的各种运算有效的进行。
本来,用二维数组存储矩阵,在逻辑上意义是很明确的,也很容易理解,操作也很容易和方便。
但是在数值分析中经常出现一些阶数很高的矩阵,同时,在矩阵中又有很多值相同或者都为零的元素,可以对这种矩阵进行压缩存储:对多个值相同的元素只分配一个存储空间;对零元素不分配空间。
稀疏矩阵的定义是一个模糊的定义:即非零元个数较零元个数较少的矩阵。
例如下图所示的矩阵为一个稀疏矩阵。
为了实现稀疏矩阵的这种存储结构,引入三元组这种数据结构。
三元组的线性表顺存储形式如下图:六、详细设计sanyuanzu.h 头文件#define max 100typedef struct{int row,col;int e;}Triple;//定义三元组typedef struct{Triple data[max];int mu,nu,tu;}TSMatrix;///*定义三元组的稀疏矩阵*/void creat( TSMatrix &M) ;void fasttrans(TSMatrix A,TSMatrix &B);void printfx(TSMatrix x);sanyuanzu.cpp 文件#include<stdio.h>#include"sanyuanzu.h"/*建立三元组的稀疏矩阵*/void creat( TSMatrix &M){printf("请输入稀疏矩阵的行数:");scanf("%d",&M.mu);printf("请输入稀疏矩阵的列数:");scanf("%d",&M.nu);printf("请输入矩阵中非零元素的个数:");scanf("%d",&M.tu);int i;printf("请输入这%d 个元素的行号和列号及其元素的值:/n",M.tu);for(i = 1; i <= M.tu;i++)scanf("%d %d %d",&M.data[i].row,&M.data[i].col,&M.data[i].e);}/*实现三元组的矩阵转置的函数*/void fasttrans(TSMatrix A,TSMatrix &B){int col,cpot[max],num[max],t,p,q;/*初始化矩阵B*/B.mu=A.nu;B.nu=A.mu;B.tu=A.tu;if(B.tu){for(col=1;col<=A.nu;++col)num[col]=0;/*初始化每一列非零元的个数*/for(t=1;t<=A.tu;++t)++num[A.data[t].col];/*计算每一列非零元的个数*/cpot[1]=1;for(col=2;col<=A.nu;++col)cpot[col]=cpot[col-1]+num[col-1];//计算矩阵A 每一列第一个非零元在B.data 中的位置/*实现对A 中的每一个非零元进行转置*/for(p=1;p<=A.tu;++p){col=A.data[p].col;q=cpot[col];B.data[q].row=A.data[p].col;B.data[q].col=A.data[p].row;B.data[q].e=A.data[p].e;++cpot[col];}}}/*稀疏矩阵的输出*/void printfx(TSMatrix x){int i,j;for(j=1;j<=x.tu;j++){for(i=1;i<=x.mu;i++)if(x.data[j].row==i)printf("%d %d %d/n",x.data[j].row,x.data[j].col,x.data[j].e );}}main.cpp 文件#include<stdio.h>#include'"sanyuanzu.cpp"//主函数int main(void){TSMatrix t,s;creat(t);printf("你所输入的稀疏矩阵为:/n");printfx(t);fasttrans(t,s);printf("转置后的稀疏矩阵为:/n");printfx(s);return 0;}}七、调试报告八、分析与遇到的问题(1)创建稀疏矩阵时,不懂如何用三元组表示元素的输出;(2)需要注意矩阵运算中的特殊状况,稀疏矩阵相加时,忘记对应元素相加为0时,在稀疏矩阵中不表示;(3)矩阵相加时,第一个矩阵的行列数要和第二个矩阵的行列数相等;(4)输出矩阵时,输出界面不整齐。
压缩存储的稀疏矩阵的转置
压缩存储的稀疏矩阵的转置一、稀疏矩阵的概念和特点稀疏矩阵是指其中大部分元素为0的矩阵。
与之相对的是密集矩阵,即其中大部分元素都不为0的矩阵。
由于稀疏矩阵中大部分元素为0,因此存储和计算时会浪费很多空间和时间资源。
因此,对于稀疏矩阵的存储和计算需要采用特殊的方法。
二、压缩存储方法1. COO(Coordinate)格式COO格式是将每个非零元素在行、列、值三个方面进行存储。
这种方法简单易懂,但是会浪费很多空间资源。
2. CSR(Compressed Sparse Row)格式CSR格式是将每一行非零元素在值和列两个方面进行存储,并记录每一行第一个非零元素所在位置。
这种方法可以节省空间资源,并且适合进行稠密向量与稀疏矩阵相乘运算。
3. CSC(Compressed Sparse Column)格式CSC格式是将每一列非零元素在值和行两个方面进行存储,并记录每一列第一个非零元素所在位置。
这种方法也可以节省空间资源,并且适合进行稀疏向量与稀疏矩阵相乘运算。
三、稀疏矩阵的转置1. COO格式的转置COO格式的转置需要将每个非零元素的行和列进行交换。
2. CSR格式的转置CSR格式的转置需要先将每一行非零元素按列排序,然后再按照CSC 格式进行存储。
3. CSC格式的转置CSC格式的转置需要先将每一列非零元素按行排序,然后再按照CSR 格式进行存储。
四、压缩存储稀疏矩阵的转置实现方法1. COO格式的压缩存储稀疏矩阵的转置实现方法:(1)遍历COO格式中每一个非零元素,将其行和列进行交换。
(2)对交换后得到的COO格式进行排序,以便于之后进行CSR或CSC格式存储。
2. CSR/CSC格式的压缩存储稀疏矩阵的转置实现方法:(1)先遍历原始CSR/CSC格式中每一行/列,记录下每一行/列第一个非零元素在新CSR/CSC中所在位置。
(2)再遍历原始CSR/CSC中每一个非零元素,在新CSR/CSC中找到其应该所在位置,并将其值赋值给新CSR/CSC中相应位置。
稀疏矩阵快速转置算法的分析与优化
21 0 0年 8月
计算机 应 用与软 件
Co mpue p ia in n ot r trAp lc t sa d S fwae o
Vo. 7 No 8 12 .
Au .2 0 g 01
稀 疏 矩 阵快 速 转 置 算 法 的分 析 与优 化
t e e t o k n so r v d ag r h , o cu e t n o t s d ag r h t a o s se h d a tg flw rt o lxt n e it g h s w id f mp o e lo i m we c n l d oa p i e lo i m t s e s st e a v n a e o e me c mpe i i x si i t mi t h p o i y n f s t s o i o l o i m w i e u e h p c o lx t f h t l o i m sw l,a d i r a h st ep r o e o p i s g e it g fs a t r p s in ag rt h l r d c st e s a e c mp e i o a g rt a el n e c e h u p s fo t a n t h e y t a h t mii x si t n n a
n umb ro o ,t tlnu e frws oa mbe fc l mn n otlnu e flo z r lme so h pas arx. T a e ie he marx fs r ns o ro o u s a d t a mb ro n—e ee nt fte s r em t i o i he p p rgv st ti a tta p —
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
实验2 稀疏矩阵的建立与转置
一、实验目的
掌握特殊矩阵的存储和操作算法。
二、实验内容及问题描述
实现用三元组保存稀疏矩阵并实现矩阵转置的算法。
三、实验步骤
1. 定义稀疏矩阵的三元组形式的存储结构。
2. 实现三元组矩阵的传统转置算法。
3. 实现三元组矩阵的快速转置算法。
4. 输入矩阵非零元素,测试自己完成的算法。
四、程序流程图
五、概要设计
矩阵是很多的科学与工程计算中研究的数学对象。
在此,我们感兴趣的是,从数学结构这门学科着眼,如何存储矩阵的元从而使矩阵的各种运算有效的进行。
本来,用二维数组存储矩阵,在逻辑上意义是很明确的,也很容易理解,操作也很容易和方便。
但是在数值分析中经常出现一些阶数很高的矩阵,同时,在矩阵中又有很多值相同或者都为零的元素,可以对这种矩阵进行压缩存储:对多个值相同的元素只分配一个存储空间;对零元素不分配空间。
稀疏矩阵的定义是一个模糊的定义:即非零元个数较零元个数较少的矩阵。
例如下图所示的矩阵
为一个稀疏矩阵。
为了实现稀疏矩阵的这种存储结构,引入三元组这种数据结构。
三元组的线性表顺存储形式如下图:
六、详细设计
sanyuanzu.h 头文件
#define max 100
typedef struct
{
int row,col;
int e;
}Triple;//定义三元组
typedef struct
{
Triple data[max];
int mu,nu,tu;
}TSMatrix;///*定义三元组的稀疏矩阵*/
void creat( TSMatrix &M) ;
void fasttrans(TSMatrix A,TSMatrix &B);
void printfx(TSMatrix x);
sanyuanzu.cpp 文件
#include<stdio.h>
#include"sanyuanzu.h"
/*建立三元组的稀疏矩阵*/
void creat( TSMatrix &M)
{
printf("请输入稀疏矩阵的行数:");
scanf("%d",&M.mu);
printf("请输入稀疏矩阵的列数:");
scanf("%d",&M.nu);
printf("请输入矩阵中非零元素的个数:");
scanf("%d",&M.tu);
int i;
printf("请输入这%d 个元素的行号和列号及其元素的值:/n",M.tu);
for(i = 1; i <= M.tu;
i++)scanf("%d %d %d",&M.data[i].row,&M.data[i].col,&M.data[i].e);
}
/*实现三元组的矩阵转置的函数*/
void fasttrans(TSMatrix A,TSMatrix &B)
{
int col,cpot[max],num[max],t,p,q;
/*初始化矩阵B*/
B.mu=A.nu;
B.nu=A.mu;
B.tu=A.tu;
if(B.tu)
{
for(col=1;col<=A.nu;++col)
num[col]=0;/*初始化每一列非零元的个数*/
for(t=1;t<=A.tu;++t)
++num[A.data[t].col];/*计算每一列非零元的个数*/
cpot[1]=1;
for(col=2;col<=A.nu;++col)
cpot[col]=cpot[col-1]+num[col-1];//计算矩阵A 每一列第一个非零元在B.data 中的位置
/*实现对A 中的每一个非零元进行转置*/
for(p=1;p<=A.tu;++p)
{
col=A.data[p].col;
q=cpot[col];
B.data[q].row=A.data[p].col;
B.data[q].col=A.data[p].row;
B.data[q].e=A.data[p].e;
++cpot[col];
}
}
}
/*稀疏矩阵的输出*/
void printfx(TSMatrix x)
{
int i,j;
for(j=1;j<=x.tu;j++)
{
for(i=1;i<=x.mu;i++)
if(x.data[j].row==i)printf("%d %d %d/n",x.data[j].row,x.data[j].col,x.data[j].e );
}
}
main.cpp 文件
#include<stdio.h>
#include'"sanyuanzu.cpp"
//主函数
int main(void)
{
TSMatrix t,s;
creat(t);
printf("你所输入的稀疏矩阵为:/n");
printfx(t);
fasttrans(t,s);
printf("转置后的稀疏矩阵为:/n");
printfx(s);
return 0;
}
}
七、调试报告
八、分析与遇到的问题
(1)创建稀疏矩阵时,不懂如何用三元组表示元素的输出;
(2)需要注意矩阵运算中的特殊状况,
稀疏矩阵相加时,忘记对应元素相加为0时,在稀疏矩阵中不表示;
(3)矩阵相加时,第一个矩阵的行列数要和第二个矩阵的行列数相等;
(4)输出矩阵时,输出界面不整齐。
九、用户使用说明
(1)运行程序,首先会看到一个提供选择的界面,输入相应的序号实现相应的功能;
(2)在进行相应的功能之后按提示要求一三元组形式输入相应矩阵。
(注意:每个数据之间用空格隔开);
(3)输入相应矩阵之后会输出最后的运算结果;
(4)输出结果运算之后会可按任意键返回。
十、心得体会
这次数据结构课程设计的制作使我对数据结构和C语言的理解加深,也使我自己认识到自己很多不足之处。
我发现自己再处理稍微具体的程序时显得无从下手以前学习的知识只是理论性的知识,并没有真正实践过,当我通过网上查询、复习知识后才对编程程序有了初步思路。
后来编写程序时也碰到了许多错误,我对于指针的掌握程度较差导致我再使用时产生了很多错误请教了老师和同学才逐步完成。
这次实验使我认识到要想做成一个完整的程序绝对不是简单的事。
我明白了无论是是做什么我们搜必须按部就班的从点滴做起,逐步完成。
最新文件---------------- 仅供参考--------------------已改成-----------word文本--------------------- 方便更改。