实验5稀疏矩阵三元组表的操作1

合集下载

数据结构实验五矩阵的压缩存储与运算学习资料

数据结构实验五矩阵的压缩存储与运算学习资料

数据结构实验五矩阵的压缩存储与运算第五章矩阵的压缩存储与运算【实验目的】1. 熟练掌握稀疏矩阵的两种存储结构(三元组表和十字链表)的实现;2. 掌握稀疏矩阵的加法、转置、乘法等基本运算;3. 加深对线性表的顺序存储和链式结构的理解。

第一节知识准备矩阵是由两个关系(行关系和列关系)组成的二维数组,因此对每一个关系上都可以用线性表进行处理;考虑到两个关系的先后,在存储上就有按行优先和按列优先两种存储方式,所谓按行优先,是指将矩阵的每一行看成一个元素进行存储;所谓按列优先,是指将矩阵的每一列看成一个元素进行存储;这是矩阵在计算机中用一个连续存储区域存放的一般情形,对特殊矩阵还有特殊的存储方式。

一、特殊矩阵的压缩存储1. 对称矩阵和上、下三角阵若n阶矩阵A中的元素满足= (0≤i,j≤n-1 )则称为n阶对称矩阵。

对n阶对称矩阵,我们只需要存储下三角元素就可以了。

事实上对上三角矩阵(下三角部分为零)和下三角矩阵(上三角部分为零),都可以用一维数组ma[0.. ]来存储A的下三角元素(对上三角矩阵做转置存储),称ma为矩阵A的压缩存储结构,现在我们来分析以下,A和ma之间的元素对应放置关系。

问题已经转化为:已知二维矩阵A[i,j],如图5-1,我们将A用一个一维数组ma[k]来存储,它们之间存在着如图5-2所示的一一对应关系。

任意一组下标(i,j)都可在ma中的位置k中找到元素m[k]= ;这里:k=i(i+1)/2+j (i≥j)图5-1 下三角矩阵a00 a10 a11 a20 … an-1,0 … an-1,n-1k= 0 1 2 3 …n(n-1)/2 …n(n+1)/2-1图5-2下三角矩阵的压缩存储反之,对所有的k=0,1,2,…,n(n+1)/2-1,都能确定ma[k]中的元素在矩阵A中的位置(i,j)。

这里,i=d-1,(d是使sum= > k的最小整数),j= 。

2. 三对角矩阵在三对角矩阵中,所有的非零元素集中在以主对角线为中心的带内状区域中,除了主对角线上和直接在对角线上、下方对角线上的元素之外,所有其它的元素皆为零,见图5-3。

三元组表示稀疏矩阵的转置(一般算法和快速算法)

三元组表示稀疏矩阵的转置(一般算法和快速算法)

三元组表示稀疏矩阵的转置(一般算法和快速算法)一、设计要求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。

稀疏矩阵的三元组顺序表存储表示及其转置算法

稀疏矩阵的三元组顺序表存储表示及其转置算法

稀疏矩阵的三元组顺序表存储表示及其转置算法目录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的情况下,只有少数非零元素的情况。

《数据结构》实验指导书

《数据结构》实验指导书
四、实验说明
1.单链表的类型定义
#include <stdio.h>
typedef int ElemType;//单链表结点类型
typedef struct LNode
{ElemType data;
struct LNode *next;
2.明确栈、队列均是特殊的线性表。
3.栈、队列的算法是后续实验的基础(广义表、树、图、查找、排序等)。
六、实验报告
根据实验情况和结果撰写并递交实验报告。
实验四 串
一、预备知识
1.字符串的基本概念
2.字符串的模式匹配算法
二、实验目的
1.理解字符串的模式匹配算法(包括KMP算法)
typedef struct
{ElemType *base;
int front,rear;
} SqQueue;
4.单链队列的类型定义
typedef struct QNode
{QElemType data;
typedef struct list
{ElemType elem[MAXSIZE];//静态线性表
int length; //顺序表的实际长度
} SqList;//顺序表的类型名
五、注意问题
1.插入、删除时元素的移动原因、方向及先后顺序。
4.三元组表是线性表的一种应用,通过它可以更好地理解线性表的存储结构。同时矩阵又是图的重要的存储方式,所以这个实验对更好地掌握线性表对将来对图的理解都有极大的帮助。
六、实验报告
根据实验情况和结果撰写并递交实验报告。
实验六 树和二叉树
一、预备知识
1.二叉树的二叉链表存储结构

实验5稀疏矩阵三元组表的操作1

实验5稀疏矩阵三元组表的操作1

实验五稀疏矩阵三元组表的操作科目:数据结构实验和课程设计班级: 10信管姓名:徐杨学号:2010110450 实验目的:会定义稀疏矩阵的三元组表。

熟悉C语言程序的基本结构,掌握程序中的用户头文件、文件之间的相互关系及各自的作用。

熟悉对稀疏矩阵的三元组表的一些基本操作和具体的函数定义。

熟悉C语言操作环境的使用以及多文件程序的输入、编辑、调试和运行的全过程。

实验要求:认真阅读和掌握本实验内容所给的全部程序。

保存和输出程序运行结果,并结合程序进行分析。

按照你对稀疏矩阵的三元组表操作的需要,编写程序代码然后运行,给出运行结果。

实验设备:每人一台安装VC6.0编写软件的计算机,公用打印机。

注意事项:要在硬盘上建立好自己的工作目录,专门用来存储自己所做的实验程序及相关数据,以后每次做实验最好仍采用这个目录。

认真编写算法及运行结果,针对本实验的具体算法,认真写出算法分析。

一、实验步骤:#include<iostream.h>//稀疏矩阵三元组表的操作#define maxsize 64#define M#define Ntypedef int elemtype;struct node{int r,c;elemtype d;};struct ts{int rows,cols,nums;node data[maxsize];};void create(ts &a);//稀疏矩阵三元组表的建立void disp(ts a);//显示稀疏矩阵三元组表的内容void trants(ts a,ts &at); //求稀疏矩阵的转置void add(ts a,ts b,ts &c);//求两稀疏矩阵的和void main(){ts a;create(a); //稀疏矩阵三元组表的建立disp(a); //显示稀疏矩阵三元组表的内容ts at;trants(a,at); //求稀疏矩阵的转置disp(at); //显示转置矩阵的内容ts b;create(b);disp(b); //稀疏矩阵三元组表的建立ts c;add(a,b,c); //求两稀疏矩阵的和disp(c); //显示两稀疏矩阵和的内容}void create(ts &a) //稀疏矩阵三元组表的建立{ cout<<"建立稀疏矩阵三元组表:"<<endl;cout<<"稀疏矩阵的行数为:";cin>>a.rows;cout<<"稀疏矩阵列的数为:";cin>>a.cols;cout<<"稀疏矩阵中非零的元素个数为:";cin>>a.nums;cout<<"稀疏矩阵的三元组表为:"<<endl;for(int i=0;i<a.nums;i++){cin>>a.data[i].r>>a.data[i].c>>a.data[i].d;}}void disp(ts a) //显示稀疏矩阵三元组表的内容{ int i;cout<<"显示稀疏矩阵三元组表:"<<endl;if(a.nums<=0) return;cout<<"行数为:"<<a.rows<<" "<<"列数为:"<<a.cols<<" "<<"元素个数为:"<<" "<<a.nums<<endl;cout<<"------------------------"<<endl;for(i=0;i<a.nums;i++)cout<<a.data[i].r<<" "<<a.data[i].c <<" "<<a.data[i].d <<endl;}void trants(ts a,ts &at)//求稀疏矩阵的转置{ int p,q=0,v;at.rows=a.cols;at.cols=a.rows;at.nums=a.nums;if(a.nums!=0){ for(v=0;v<a.cols;v++)for(p=0;p<a.nums;p++)if(a.data[p].c==v){at.data[q].r=a.data[p].c;at.data[q].c=a.data[p].r;at.data[q].d=a.data[p].d;q++;}}cout<<"转置后的稀疏矩阵:"<<endl;}void add(ts a,ts b,ts &c) //求两稀疏矩阵的和{int i=0,j=0,k=0;elemtype v;if (a.rows!=b.rows||a.cols!=b.cols)c.rows=a.rows;c.cols=a.cols;while (i<a.nums&&j<b.nums){if(a.data[i].r==b.data[j].r){if(c.data[i].c<b.data[j].c){c.data[k].r=a.data[i].r;c.data[k].c=a.data[i].c;c.data[k].d=a.data[i].d;k++;i++;}else if(a.data[i].c>b.data[j].c){c.data[k].r=b.data[j].r;c.data[k].c=b.data[j].c;c.data[k].d=b.data[j].d;k++;j++;}else{v=a.data[i].d+b.data[j].d;if(v!=0){c.data[k].r=a.data[i].r;c.data[k].c=a.data[i].c;c.data[k].d=v;k++;}i++;j++;}}else if(a.data[i].r<b.data[j].r){c.data[k].r=a.data[i].r;c.data[k].c=a.data[i].c;c.data[k].d=a.data[i].d;k++;i++;}else{c.data[k].r=b.data[j].r;c.data[k].c=b.data[j].c;c.data[k].d=b.data[j].d;k++;j++;}c.nums=k;}cout<<"两个稀疏矩阵求和后元素的个数为:"<<c.nums<<endl; }二、运行结果:三、算法分析:。

稀疏矩阵——三元组顺序表

稀疏矩阵——三元组顺序表

稀疏矩阵——三元组顺序表⽬录稀疏矩阵假设m*n的矩阵中,有t的⾮零元,令s=t/m * n,当,s<=0.05时,称此矩阵为稀疏矩阵,简单理解就是⾮零元特别少的矩阵//⼀般矩阵a1 2 3a= 4 5 67 8 9//稀疏矩阵s0 0 0 0 00 2 0 0 5s= 0 0 3 0 00 0 0 0 4矩阵的转置⼀个m * n的矩阵转置后变为 n * m的矩阵//3*2的矩阵-转置前1 24 57 8//转置后变为2*31 4 72 5 8转置后的矩阵每个元素的下表与原来的下表刚好相反,例如上⾯4转置前的下标为(2,1),转置后变为(1,2);矩阵压缩存储-三元组顺序表之所以引⼊三元组顺序表,是因为,对于稀疏矩阵⽽⾔,⽤传统的存储⽅法会造成存储空间的浪费0 12 9 0 0 0 00 0 0 0 0 0 0-3 0 0 0 0 14 0M= 0 0 24 0 0 0 00 18 0 0 0 0 015 0 0 -7 0 0 0//上⾯矩阵⽤三元组表⽰i j v1 2 121 3 93 1 -33 6 144 3 245 2 186 1 156 4 -7typedef struct{int i,j; //⾏坐标、列坐标ElemType e; //元素}Triple;typedef struct{Triple date[MAXSIZE+1]; //0不存储元素int mu,nu,tu; //⾏数、列数、⾮零元个数}TSMatrix;稀疏矩阵的转置传统⽅法的转置算法时遍历矩阵的每⼀项,交换其下标值即可for(col=1;col<=nu;col++){for(row=1;row<=mu;row++){T[col][row]=M[row][col]}}//时间复杂度 : O(nu*mu)利⽤三元组顺序表进⾏存储的稀疏矩阵要想实现转置显然不能⽤上⾯的算法,下⾯介绍两种⽅法:第⼀种:以列序为主序的转置//置换前存储位置i j v1 2 12 -> M.date[1]1 3 9 -> M.date[2]3 1 -3 -> M.date[3]3 6 14 -> M.date[4]4 3 24 -> M.date[5]5 2 18 -> M.date[6]6 1 15 -> M.date[7]6 4 -7 -> M.date[8]//置换后存储位置i j v1 3 -3 -> T.date[1]1 6 15 -> T.date[2]2 1 12 -> T.date[3]2 5 18 -> T.date[4]3 1 9 -> T.date[5]3 4 24 -> T.date[6]4 6 -7 -> T.date[7]6 3 14 -> T.date[8]void TransposeSMatrix(TSMatrix *T1,TSMatrix *T2){T2->mu=T1->nu;T2->nu=T1->mu;T2->tu=T1->tu;if(T1->tu){int q=1,col,p;for(col=1;col<=T1->nu;col++) //矩阵列循环{for(p=1;p<=T1->tu;p++) //遍历所有元素{if(T1->date[p].j==col) //当元素在col列时{T2->date[q].i=T1->date[p].j;T2->date[q].j=T1->date[p].i;T2->date[q].e=T1->date[p].e;q++;}}}}}//上述代码,当矩阵运算为满时,即tu=mu*nu,其时间复杂度为O(nu*nu*mu)//这种情况与经典算法相⽐,虽节省了存储空间,但是效率较低第⼆种:快速转置第⼀种算法是通过遍历所有元素的下标,从⽽确定其在转置后数组中的位置,快速转置的思想就是,预先确定每⼀列第⼀个⾮零元在对应转置后的数组date中的位置;因此需要两个辅助数组num[]:⽤来存放每⼀列的⾮零元个数cpot[]:存放第⼀个⾮零元在转置后数组date中的位置num[]数组的值很好求,只需要遍历⼀次所有元素即可for(t=1;t<=T1->tu;t++)++num[T1->date[t].j];对于cpot[],有⼀个规律col 1 2 3 4 5 6 7num[col] 2 2 2 1 0 1 0cpot[col] 1 3 5 7 8 8 9//规律copt[1]=1copt[col]=copt[col-1]+num[col-1]代码:void FastTransposeSMatrix(TSMatrix *T1,TSMatrix *T2){int num[T1->nu],cpot[T1->nu];int col,p,q,t;T2->mu=T1->nu;T2->nu=T1->mu;T2->tu=T1->tu;if(T1->tu){//初始化每列⾮零元个数为0for(col=1;col<=T1->nu;col++){num[col]=0;}//求每列⾮零元个数for(t=1;t<=T1->tu;t++){++num[T1->date[t].j];}//求每列第⼀个⾮零元转置后的位置cpot[1]=1;for(col=2;col<=T1->nu;col++){cpot[col]=num[col-1]+cpot[col-1];}//遍历所有元素for(p=1;p<=T1->tu;p++){col=T1->date[p].j; //获取列坐标q=cpot[col]; //获取新位置T2->date[q].i=T1->date[p].j;T2->date[q].j=T1->date[p].i;T2->date[q].e=T1->date[p].e;++cpot[col]; //之所以这个地⽅要++,因为每列⾮零元可能不⽌⼀个 }}}完整代码:#include <stdio.h>#include <stdlib.h>#define MAXSIZE 12500 //⾮零元个数的最⼤值typedef int ElemType;typedef struct{int i,j;ElemType e;}Triple;typedef struct{Triple date[MAXSIZE+1];int mu,nu,tu;}TSMatrix;//输⼊元素void Insert(TSMatrix *T){printf("请依次输⼊⾏数i、列数j、⾮零元个数sum:\n");int sum ;scanf("%d%d%d",&T->mu,&T->nu,&sum);T->tu=sum;int x,y,num;printf("请依次输⼊矩阵⾮零元的⾏坐标i、列坐标j、元素值x:\n");printf("i j v\n");for(int i=1 ;i<=sum;i++){scanf("%d%d%d",&x,&y,&num);T->date[i].i=x;T->date[i].j=y;T->date[i].e=num;}}//第⼀种转置⽅法void TransposeSMatrix(TSMatrix *T1,TSMatrix *T2)T2->mu=T1->nu;T2->nu=T1->mu;T2->tu=T1->tu;if(T1->tu){int q=1,col,p;for(col=1;col<=T1->nu;col++){for(p=1;p<=T1->tu;p++){if(T1->date[p].j==col){T2->date[q].i=T1->date[p].j;T2->date[q].j=T1->date[p].i;T2->date[q].e=T1->date[p].e;q++;}}}}}//输出矩阵⾮零元void Show(TSMatrix *T){printf("转置后的矩阵:\n");printf("i j v\n");for(int i=1;i<=T->tu;i++){printf("%d %d %d\n",T->date[i].i,T->date[i].j,T->date[i].e); }}//快速转置void FastTransposeSMatrix(TSMatrix *T1,TSMatrix *T2){int num[T1->nu],cpot[T1->nu];int col,p,q,t;T2->mu=T1->nu;T2->nu=T1->mu;T2->tu=T1->tu;if(T1->tu){//初始化每列⾮零元个数为0for(col=1;col<=T1->nu;col++){num[col]=0;}//求每列⾮零元个数for(t=1;t<=T1->tu;t++){++num[T1->date[t].j];}cpot[1]=1;for(col=2;col<=T1->nu;col++){cpot[col]=num[col-1]+cpot[col-1];}for(p=1;p<=T1->tu;p++){col=T1->date[p].j;q=cpot[col];T2->date[q].i=T1->date[p].j;T2->date[q].j=T1->date[p].i;T2->date[q].e=T1->date[p].e;++cpot[col];}}}int main(){TSMatrix T,T1,*q,*p;p=&T;q=&T1;Insert(p);//测试第⼀种转置⽅法TransposeSMatrix(p, q);Show(q);//测试快速转置FastTransposeSMatrix(p, q);Show(q);}/* 测试请依次输⼊⾏数i、列数j、⾮零元个数sum:6 7 8请依次输⼊矩阵⾮零元的⾏坐标i、列坐标j、元素值x:1 2 121 3 93 1 -33 6 144 3 245 2 186 1 156 4 -7转置后的矩阵:i j v1 3 -31 6 152 1 122 5 183 1 93 4 244 6 -76 3 14转置后的矩阵:i j v1 3 -31 6 152 1 122 5 183 1 93 4 244 6 -76 3 14Program ended with exit code: 0*/我不⽣产代码,我只是代码的搬运⼯。

实验报告五:稀疏矩阵的三元组实现实验

实验报告五:稀疏矩阵的三元组实现实验

实验报告
实验五稀疏矩阵的三元组实现实验(4学时)
实验目的:
掌握稀疏矩阵的三元组表示方法、算法实现。

实验内容:(类C算法的程序实现,任选其二)
(1) 基于三元组的稀疏矩阵表示与输入、输出方法(必做);
(2) 基于三元组的稀疏矩阵加法(选做);
(3) 基于三元组表示的稀疏矩阵转置(选做);
(4) 基于三元组表示的稀疏矩阵的乘法(选做)。

实验准备:
1) 计算机设备;2) 程序调试环境的准备,如TC环境;3) 实验内容的算法分析与代码设计与分析准备。

实验步骤:
1.录入程序代码并进行调试和算法分析;
2.编写实验报告。

实验结果:
试验的完整的C程序代码,以及程序实现与结果分析。

源程序:
1,三元组的顺序表存储表示
2,创建一个稀疏矩阵
3,表示这个矩阵
4,主函数
最终结果:。

(10)稀疏矩阵的三元组表存储方法

(10)稀疏矩阵的三元组表存储方法

求解
b .data 4 b .data 5 b .data 6 b .data 7 b .data 8
a. mu=6 a. nu=7 a. tu=8
注:p=1..8,寻找 a.data[ p].j==col 寻找
2.求解步骤分析:p=1..8, q的值 求解步骤分析: 的值=7 求解步骤分析 的值
注意: 注意:
为了保存矩阵的行数、 为了保存矩阵的行数、列 数和非零元素个数, 数和非零元素个数,还需 增设三个量: 增设三个量:mu nu tu
mu=6 nu=7 tu=8
3.三元组线性表的数据类型描述 3.三元组线性表的数据类型描述
#define MAXSIZE 12500 typedef struc{ int ElemType }Triple; typedef struc{ Triple data [MAXSIZE+1]; //三元组表,data[0]不用 三元组表, 三元组表 不用 int mu , nu , tu ; }TSMatrix TSMatrix M ; //矩阵的行数、列数、非0元素个数 矩阵的行数、列数、 矩阵的行数 元素个数 //sparseness(稀疏 稀疏) 稀疏 i, j; e; //非零元素个数的最大值 非零元素个数的最大值
世界那么世界那么大大我们去看我们去看看看世界那么世界那么大大我们去看我们去看看看世界那么世界那么大大我们去看我们去看看看世界那么世界那么大大我们去看我们去看看看世界那么世界那么大大我们去看我们去看看看世界那么世界那么大大我们去看我们去看看看世界那么世界那么大大我们去看我们去看看看sparsematrix例如
求解
b .data 4 b .data 5 b .data 6 b .data 7 b .data 8

稀疏矩阵实验报告

稀疏矩阵实验报告

一、实验目的1. 理解稀疏矩阵的概念和特点。

2. 掌握稀疏矩阵的三元组表示方法。

3. 熟悉稀疏矩阵的基本运算,如转置、加法、减法等。

4. 提高编程能力和问题解决能力。

二、实验环境1. 操作系统:Windows 102. 编程语言:C++3. 开发工具:Visual Studio 2019三、实验内容1. 稀疏矩阵的三元组表示- 设计稀疏矩阵的三元组存储结构。

- 编写函数实现稀疏矩阵的三元组表示。

2. 稀疏矩阵的基本运算- 实现稀疏矩阵的转置。

- 实现稀疏矩阵的加法、减法。

- 实现稀疏矩阵的乘法。

3. 实验结果分析- 对实验结果进行分析,比较稀疏矩阵与普通矩阵运算的效率。

四、实验步骤1. 稀疏矩阵的三元组表示- 定义稀疏矩阵的三元组存储结构,包括行号、列号和元素值。

- 编写函数实现稀疏矩阵的三元组表示,包括读取稀疏矩阵的三元组数据、构建稀疏矩阵的三元组表示等。

2. 稀疏矩阵的基本运算- 实现稀疏矩阵的转置,包括交换行号和列号、重新排序等。

- 实现稀疏矩阵的加法、减法,包括遍历两个稀疏矩阵的三元组,计算对应元素的加法或减法结果。

- 实现稀疏矩阵的乘法,包括遍历两个稀疏矩阵的三元组,计算对应元素的乘法结果。

3. 实验结果分析- 对实验结果进行分析,比较稀疏矩阵与普通矩阵运算的效率。

- 分析实验结果,得出稀疏矩阵运算的优缺点。

五、实验结果1. 稀疏矩阵的三元组表示- 读取稀疏矩阵的三元组数据,构建稀疏矩阵的三元组表示。

2. 稀疏矩阵的基本运算- 实现稀疏矩阵的转置,包括交换行号和列号、重新排序等。

- 实现稀疏矩阵的加法、减法,包括遍历两个稀疏矩阵的三元组,计算对应元素的加法或减法结果。

- 实现稀疏矩阵的乘法,包括遍历两个稀疏矩阵的三元组,计算对应元素的乘法结果。

3. 实验结果分析- 稀疏矩阵运算效率比普通矩阵运算高,尤其在稀疏程度较高的矩阵上。

- 稀疏矩阵运算的缺点是存储空间较大,且运算过程中需要频繁进行数据交换。

数据结构-稀疏矩阵的三元组表存储方法

数据结构-稀疏矩阵的三元组表存储方法

0 0 -3 0 0 15
0 12 9 0 0 0 0
12 0 0 0 18 0
00 00000
9 0 0 24 0 0
M= -3 0 0 0 0 14 0 0 0 24 0 0 0 0
求解 N=
0 0 0 0 0 -7 0000 00
0 18 0 0 0 0 0
0 0 14 0 0 0
15 0 0 0 0 0
4 3 24 5 2 18
注意:
data 7 data 8
6 1 15 6 4 -7
mu=6 nu=7 tu=8
为了保存矩阵的行数、列 数和非零元素个数,还需 增设三个量:mu nu tu
3.三元组线性表的数据类型描述
#define MAXSIZE 12500 //非零元素个数的最大值
typedef struct{
稀疏矩阵的压缩存储 ———三元组表
一、什么是稀疏矩阵(sparse matrix)
如果矩阵M中的大多数元素均 为零元素,则称矩阵M为稀疏矩 阵 。一般地,当非零元素个数 只占矩阵元素总数的25%—30%, 或低于这个百分数时,我们称这样 的矩阵为稀疏矩阵。
一、什么是稀疏矩阵(sparse matrix)
3.算法描述
status TransposeSMatrix(TSMatrix a, TSMatrix *b){ (*b).mu=a.nu; (*b).nu=a.mu; (*b).tu=a.tu; if ((*b).tu) { q= 1; for (col= 1 ; col<= a.nu ; + + col) for (p= 1 ; p<= a.tu ; + +p) if (a.data[p] .j = =col) { b.data[q].i=a.data[p] .j; b.data[q].j=a.data[p] .i; b.data[q].e=a.data[p].e; ++q; } return OK;

数据结构-稀疏矩阵的三元组表存储方法

数据结构-稀疏矩阵的三元组表存储方法

a .data 3 3 1 -3
b .data 3 2 1 12
a .data 4 3 6 14 求得 b .data 4 2 5 18
a .data 5 a .data 6 a .data 7
4 3 24
5 2 18 无!
6 1 15
b .data 5 b .data 6 b .data 7
31 9 3 4 24 4 6 -7
b .data 2 1 6 15
a .data 3 3 1 -3
b .data 3 2 1 12
a .data 4 3 6 14 求解 b .data 4 2 5 18
a .data 5 4 3 24
b .data 5 3 1 9
a .data 6 5 2 18
b .data 6 3 4 24
a .data 7 6 1 15
a .data 5 4 3 24
b .data 5
a .data 6 5 2 18
b .data 6
a .data 7 6 1 15
b .data 7
a .data 8 6 4 -7
b .data 8
a. mu=6 a. nu=7 a. tu=8 注:p=1:8,寻找 j=col 的a.data[ p]
a .data 2 1 3 9 Col=6 b .data 2 1 6 15
a .data 3 a .data 4
3 1 -3
b .data 3
3 6 14 求得 b .data 4
2 1 12 2 5 18
a .data 5 4 3 24
b .data 5 3 1 9
a .data 6 5 2 18
2.求解步骤分析:p=1:8, q的值=7

实现稀疏矩阵采用三元组表示的基本运算实验报告

实现稀疏矩阵采用三元组表示的基本运算实验报告

实现稀疏矩阵(采用三元组表示)的基本运算实验报告实现稀疏矩阵(采用三元组表示)的基本运算实验报告一实验题目: 实现稀疏矩阵(采用三元组表示)的基本运算二实验要求:(1)生成如下两个稀疏矩阵的三元组a 和 b;(上机实验指导 P92 )(2)输出 a 转置矩阵的三元组;(3)输出a + b 的三元组;(4)输出 a * b 的三元组;三实验内容:3.1 稀疏矩阵的抽象数据类型:ADT SparseMatrix {数据对象:D={aij| i = 1,2,3,….,m; j =1,2,3,……,n;ai,j∈ElemSet,m 和n分别称为矩阵的行数和列数 }数据关系 : R={ Row , Col }Row ={<ai,j ,ai,j+1> | 1≤ i≤m , 1≤ j ≤ n-1}Col ={<a i,j , a i+1,j >| 1≤i≤m-1,1≤j ≤n}基本操作:CreateSMatrix(&M)操作结果:创建稀疏矩阵M PrintSMatrix(M)初始条件:稀疏矩阵M已经存在操作结果:打印矩阵M DestroySMatrix(&M)初始条件:稀疏矩阵M已经存在操作结果:销毁矩阵M CopySMatrix(M, &T)初始条件:稀疏矩阵M已经存在操作结果:复制矩阵M到TAddSMatrix(M, N, &Q)初始条件:稀疏矩阵M、N已经存在操作结果:求矩阵的和Q=M+N SubSMatrix(M, N, &Q)初始条件:稀疏矩阵M、N已经存在操作结果:求矩阵的差Q=M-N TransposeSMatrix(M, & T)初始条件:稀疏矩阵M已经存在操作结果:求矩阵M的转置T MultSMatrix(M, N, &Q)初始条件:稀疏矩阵M已经存在操作结果:求矩阵的积Q=M*N }ADT SparseMatrix3.2存储结构的定义#define N 4typedef int ElemType;#define MaxSize 100 //矩阵中非零元素最多个数typedef struct{ int r; //行号int c; //列号ElemType d; //元素值} TupNode; //三元组定义typedef struct{ int rows; //行数值int cols; //列数值int nums; //非零元素个数TupNode data[MaxSize];} TSMatrix; //三元组顺序表定义3.3基本操作实现:void CreatMat(TSMatrix &t,ElemType A[N][N]){int i,j;t.rows=N;t.cols=N;t.nums=0;for (i=0;i<N;i++){for (j=0;j<N;j++)if (A[i][j]!=0){t.data[t.nums].r=i;t.data[t.nu ms].c=j;t.data[t.nums].d=A[i][j];t.nums++;}}}void DispMat(TSMatrix t){int i;if (t.nums<=0)return;printf("\t%d\t%d\t%d\n",t.rows ,t.cols,t.nums);printf("\t------------------\n ");for (i=0;i<t.nums;i++)printf("\t%d\t%d\t%d\n",t.data[i] .r,t.data[i].c,t.data[i].d);3.4解题思路:1.转置矩阵:只要判定原矩阵有值,那么只要遍历一遍原矩阵,把原来矩阵中非0元素行列变换一下赋值到新的矩阵中即可。

三元组顺序表表示的稀疏矩阵加法

三元组顺序表表示的稀疏矩阵加法

三元组顺序表表示的稀疏矩阵加法三元组顺序表表示的稀疏矩阵加法引言:稀疏矩阵是指在矩阵中大部分元素为零的情况下,只有很少非零元素的矩阵。

由于矩阵运算的复杂性,对于大型稀疏矩阵,使用传统的矩阵加法算法会消耗大量的时间和内存资源。

因此,为了高效地进行稀疏矩阵的加法运算,可以使用三元组顺序表来表示稀疏矩阵,并通过特定的算法来实现加法操作。

本文将介绍三元组顺序表和稀疏矩阵加法,并逐步回答以下问题:1. 什么是三元组顺序表?2. 什么是稀疏矩阵加法?3. 如何使用三元组顺序表进行稀疏矩阵加法操作?一、什么是三元组顺序表?三元组顺序表是一种用来高效表示稀疏矩阵的数据结构。

在三元组顺序表中,每个非零元素用一个三元组表示,包括元素的行号、列号和值。

同时,三元组顺序表中还包含两个整数,分别表示矩阵的行数和列数。

例如,如果有一个3x3的稀疏矩阵如下:1 0 20 4 03 0 5使用三元组顺序表来表示这个矩阵,可以得到如下的三元组:(0, 0, 1), (0, 2, 2), (1, 1, 4), (2, 0, 3), (2, 2, 5)二、什么是稀疏矩阵加法?稀疏矩阵加法是指对两个稀疏矩阵进行加法运算的操作。

对于给定的两个稀疏矩阵A和B,稀疏矩阵加法的结果矩阵C的每个元素等于矩阵A和B中对应位置的元素之和。

三、使用三元组顺序表进行稀疏矩阵加法操作的步骤为了实现稀疏矩阵加法,可以按照以下步骤进行:1. 定义一个存储稀疏矩阵的三元组顺序表:使用一个结构体将矩阵的行、列和非零元素存储起来。

2. 输入矩阵A和B的维度:获取矩阵A和B的行数和列数,以及非零元素的个数。

3. 输入矩阵A和B的非零元素:获取矩阵A和B的非零元素的行号、列号和值,并将其存储到三元组顺序表中。

4. 对三元组顺序表进行排序:根据三元组的行号和列号进行排序,以便后续的加法运算。

5. 进行稀疏矩阵加法运算:从头开始遍历三元组顺序表,依次取出每个三元组,根据其行号和列号在结果矩阵C中进行加法运算。

稀疏矩阵的三元组表示和实现

稀疏矩阵的三元组表示和实现

稀疏矩阵的三元组表示和实现稀疏矩阵是指在一个大型矩阵中,绝大部分元素为零,只有少部分元素非零。

在实际应用中,由于很多矩阵中只有极少数的元素具有实际意义,这种情况是很常见的。

为了节省存储空间和提高计算效率,我们可以使用三元组表示稀疏矩阵,并进行相应的实现。

三元组表示稀疏矩阵的基本思想是将矩阵中的非零元素的行、列及其值存储起来,以此表示整个稀疏矩阵。

它可以使用三个数组来实现:一个数组用于存储非零元素的值,一个数组用于存储非零元素的行号,另一个数组用于存储非零元素的列号。

这样,对于一个m×n的稀疏矩阵,这三个数组的长度就是非零元素的个数。

三元组表示的稀疏矩阵在实际应用中具有以下特点:1.节省存储空间:由于只存储非零元素,因此可以大大减少存储空间的使用,尤其在元素总数远大于非零元素数目的情况下。

2.提高计算效率:对于稀疏矩阵,很多计算操作可以直接跳过零元素,只对非零元素进行计算,从而提高计算效率。

3.易于读取和修改:三元组表示使得读取和修改稀疏矩阵变得相对容易,因为只需要根据存储的三元组信息进行操作即可。

在实现三元组表示稀疏矩阵时,首先需要确定数据结构的形式。

一种常见的方式是使用类来表示三元组,其中类的成员变量分别对应非零元素的值、行号和列号。

这样每个实例对象代表一个非零元素。

另外,还可以使用数组来表示存储该矩阵所有的非零元素。

接下来是具体的实现步骤:1.初始化一个空的三元组数组,长度为非零元素的个数。

2.遍历整个稀疏矩阵,当遇到一个非零元素时,将其值、行号和列号分别存储到三元组数组中的对应位置。

3.结束遍历后,三元组数组中的每一个实例对象就代表一个非零元素。

4.根据实际应用的需要,可以在三元组数组中实现相应的操作,如查找指定位置的元素、修改元素的值等。

对于稀疏矩阵的三元组表示的实现,有以下几个注意点:1.非零元素的顺序:算法的效率与非零元素的顺序有关,可以对非零元素按行或列的顺序进行排序,这样可以提高一些查找操作的效率。

稀疏矩阵的三元组链表

稀疏矩阵的三元组链表

(4)取数组元素 Get(D, i)
5.2 动态数组
数组有静态存储结构的数组和动态存储结构的数组两种,它们 的区别在于:
静态数组在定义时就必须给出数组个数;
动态数组是在具体申请存储单元空间时才给出数组元素的个数。 Datatype * p; p = (Datatype *)malloc(sizeof(Datatype)*n) if (NULL == p) {…} … free(p); p = NULL;
k=
i(i-1)/2+j-1
பைடு நூலகம்
当i≥j 当i<j
n(n+1)/2 (或空)
注:此时一维数组sa的数据元素个数为(n(n+1)/2)+1个,其中数组 sa的最后一个位置存储A中数值不为0的那个常数。
5.4 稀疏矩阵
1.概念
1、稀疏矩阵 矩阵中非零元素的个数远远小于矩阵元素个数。 2、稠密矩阵 一个不稀疏的矩阵。 3、稀疏矩阵压缩存储方法 只存储稀疏矩阵中的非零元素,实现方法是:将每个非零 元素用一个三元组(i,j,aij)来表示,则每个稀疏矩阵可用 一个三元组线性表来表示。
rows
... ...
7 6 6
cols dNum
6 6 maxSize-1
cols dNum
(b)
maxSize-1
(a)
稀疏矩阵的三元组链表
(1)三元组链表 用链表存储的三元组线性表。 (2)行指针数组结构的三元组链表 把每行非零元素三元组组织成一个单链表,再设计一个指针 类型的数组存储所有单链表的头指针。 (3)三元组十字链表 把非零元素三元组按行和按列组织成单链表,这样稀疏矩阵 中的每个非零元素三元组结点都将既勾链在行单链表上,又 勾链在列单链表上,形成十字形状。

稀疏矩阵的三元组表

稀疏矩阵的三元组表

稀疏矩阵的三元组表1. 什么是稀疏矩阵?稀疏矩阵是指元素中绝大多数为0的矩阵。

对于大规模的数据集,很多情况下,数据中存在大量的零值,这样的数据集被称为稀疏数据集。

相反,如果一个矩阵中绝大多数元素都非零,则被称为密集矩阵。

由于稀疏矩阵中存在大量的零值,因此存储和处理这样的数据结构会浪费很多资源。

2. 稀疏矩阵表示方法为了高效地存储和处理稀疏矩阵,人们提出了多种表示方法。

其中一种常用的方法是三元组表(Triplet Representation),也被称为COO(Coordinate)表示法。

在三元组表中,每个非零元素都由三个信息组成:行号、列号和对应的值。

通过将非零元素以这种方式进行存储,可以减少存储空间并提高计算效率。

3. 三元组表的结构三元组表通常由一个二维数组表示。

数组的每一行代表一个非零元素,并包含三个字段:行号、列号和对应的值。

下面是一个示例:行号列号值0 1 2.51 0 -1.21 2 3.72 0 4.9上面的示例表示了一个3x3的稀疏矩阵,其中只有四个非零元素。

通过三元组表的方式,我们可以明确地知道这四个非零元素的位置和值。

4. 使用三元组表进行稀疏矩阵运算三元组表不仅可以用于存储稀疏矩阵,还可以用于进行稀疏矩阵之间的运算。

例如,我们可以使用三元组表来实现稀疏矩阵的加法、减法和乘法等操作。

对于加法和减法,我们只需要遍历两个三元组表,并按行号和列号进行匹配。

如果行号和列号都相同,则将对应的值相加或相减;如果只存在一个三元素中,则直接将该三元素添加到结果中。

对于乘法,我们需要利用稀疏矩阵的特性来提高计算效率。

由于稀疏矩阵中存在大量的零值,我们可以通过跳过这些零值来减少运算次数。

具体而言,我们可以使用两个指针分别指向两个三元组表中的非零元素,然后按行号和列号进行匹配。

如果行号和列号都相同,则将对应的值相乘,并将结果累加到最终的结果矩阵中。

5. 三元组表的优缺点三元组表作为一种稀疏矩阵表示方法,具有以下优点:•存储空间效率高:只存储非零元素的位置和值,避免了存储大量的零值。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

实验五稀疏矩阵三元组表的操作
科目:数据结构实验和课程设计班级: 10信管姓名:徐杨学号:2010110450 实验目的:
会定义稀疏矩阵的三元组表。

熟悉C语言程序的基本结构,掌握程序中的用户头文件、文件之间的相互关系及各自的作用。

熟悉对稀疏矩阵的三元组表的一些基本操作和具体的函数定义。

熟悉C语言操作环境的使用以及多文件程序的输入、编辑、调试和运行的全过程。

实验要求:
认真阅读和掌握本实验内容所给的全部程序。

保存和输出程序运行结果,并结合程序进行分析。

按照你对稀疏矩阵的三元组表操作的需要,编写程序代码然后运行,给出运行结果。

实验设备:
每人一台安装VC6.0编写软件的计算机,公用打印机。

注意事项:
要在硬盘上建立好自己的工作目录,专门用来存储自己所做的实验程序及相关数据,以后每次做实验最好仍采用这个目录。

认真编写算法及运行结果,针对本实验的具体算法,认真写出算法分析。

一、实验步骤:
#include<iostream.h>//稀疏矩阵三元组表的操作
#define maxsize 64
#define M
#define N
typedef int elemtype;
struct node{int r,c;elemtype d;};
struct ts{int rows,cols,nums;node data[maxsize];};
void create(ts &a);//稀疏矩阵三元组表的建立
void disp(ts a);//显示稀疏矩阵三元组表的内容
void trants(ts a,ts &at); //求稀疏矩阵的转置
void add(ts a,ts b,ts &c);//求两稀疏矩阵的和
void main()
{
ts a;create(a); //稀疏矩阵三元组表的建立
disp(a); //显示稀疏矩阵三元组表的内容
ts at;trants(a,at); //求稀疏矩阵的转置
disp(at); //显示转置矩阵的内容
ts b;create(b);disp(b); //稀疏矩阵三元组表的建立
ts c;add(a,b,c); //求两稀疏矩阵的和
disp(c); //显示两稀疏矩阵和的内容
}
void create(ts &a) //稀疏矩阵三元组表的建立
{ cout<<"建立稀疏矩阵三元组表:"<<endl;
cout<<"稀疏矩阵的行数为:";cin>>a.rows;
cout<<"稀疏矩阵列的数为:";cin>>a.cols;
cout<<"稀疏矩阵中非零的元素个数为:";cin>>a.nums;
cout<<"稀疏矩阵的三元组表为:"<<endl;
for(int i=0;i<a.nums;i++)
{
cin>>a.data[i].r>>a.data[i].c>>a.data[i].d;
}
}
void disp(ts a) //显示稀疏矩阵三元组表的内容
{ int i;
cout<<"显示稀疏矩阵三元组表:"<<endl;
if(a.nums<=0) return;
cout<<"行数为:"<<a.rows<<" "<<"列数为:"<<a.cols<<" "<<"元素个数为:"<<" "<<a.nums<<endl;
cout<<"------------------------"<<endl;
for(i=0;i<a.nums;i++)
cout<<a.data[i].r<<" "<<a.data[i].c <<" "<<a.data[i].d <<endl;
}
void trants(ts a,ts &at)//求稀疏矩阵的转置
{ int p,q=0,v;
at.rows=a.cols;at.cols=a.rows;at.nums=a.nums;
if(a.nums!=0)
{ for(v=0;v<a.cols;v++)
for(p=0;p<a.nums;p++)
if(a.data[p].c==v)
{at.data[q].r=a.data[p].c;
at.data[q].c=a.data[p].r;
at.data[q].d=a.data[p].d;
q++;
}
}
cout<<"转置后的稀疏矩阵:"<<endl;
}
void add(ts a,ts b,ts &c) //求两稀疏矩阵的和
{int i=0,j=0,k=0;
elemtype v;
if (a.rows!=b.rows||a.cols!=b.cols)
c.rows=a.rows;c.cols=a.cols;
while (i<a.nums&&j<b.nums)
{
if(a.data[i].r==b.data[j].r)
{
if(c.data[i].c<b.data[j].c)
{
c.data[k].r=a.data[i].r;
c.data[k].c=a.data[i].c;
c.data[k].d=a.data[i].d;
k++;i++;
}
else if(a.data[i].c>b.data[j].c)
{
c.data[k].r=b.data[j].r;
c.data[k].c=b.data[j].c;
c.data[k].d=b.data[j].d;
k++;j++;
}
else
{
v=a.data[i].d+b.data[j].d;
if(v!=0)
{
c.data[k].r=a.data[i].r;
c.data[k].c=a.data[i].c;
c.data[k].d=v;
k++;
}
i++;j++;
}
}
else if(a.data[i].r<b.data[j].r)
{
c.data[k].r=a.data[i].r;
c.data[k].c=a.data[i].c;
c.data[k].d=a.data[i].d;
k++;
i++;
}
else{
c.data[k].r=b.data[j].r;
c.data[k].c=b.data[j].c;
c.data[k].d=b.data[j].d;
k++;j++;
}
c.nums=k;
}
cout<<"两个稀疏矩阵求和后元素的个数为:"<<c.nums<<endl; }
二、运行结果:
三、算法分析:。

相关文档
最新文档