实验报告----数据结构课程设计稀疏矩阵的应用

合集下载

数据结构-稀疏矩阵实验报告

数据结构-稀疏矩阵实验报告
总结与思考通过此次实验我掌握了很多矩阵的存储方法和存储结构熟悉了稀疏矩阵的三元组表和十字链表存储结构以及特殊矩阵的压缩存储方法及压缩存储下的矩阵的运算
实验报告
课程 学号 数据结构 姓名 实验名称 实验四 稀疏矩阵 实验日 期: 2012/11/12
实验四 实验目的:稀疏矩阵1.熟悉数组在计算机内存中存储的实现机制; 2.熟练并掌握数组的基本运算; 3.熟悉并掌握特殊矩阵的压缩存储方法及压缩存储下的矩阵的运算; 3.熟悉稀疏矩阵的“三元组表”和“十字链表”存储结构。
if(i<=j) { for(k=1;k<=n;k++) { if(i<=k) p=k*(k-1)/2+i-1; else p=n*(n+1)/2; if(j>=k) q=j*(j-1)/2+k-1; else q=n*(n+1)/2; sum=sum+a[p]*b[q]; } c[j*(j-1)/2+i-1]=sum; sum=0; } else c[n*(n+1)/2]=0; } } void print(int a[], int n) { int i,j; for(i=1;i<=n;i++) { for(j=1;j<=n;j++) { if(i<=j) printf("%5d", a[j*(j-1)/2+i-1]); else printf("%5d", a[n*(n+1)/2]); } printf("\n"); } } void main() { int u[]={1,2,4,3,5,6,0}; int v[]={10,20,40,30,50,60,0}; int c[7], n=3; add(u,v,c,n); printf("C=A+B=\n"); print(c,n);

数据结构实验报告三稀疏矩阵的运算

数据结构实验报告三稀疏矩阵的运算

数据结构实验报告三稀疏矩阵的运算实验课程名称数据结构课程设计专业班级学⽣姓名学号指导教师2012 ⾄ 2013 学年第⼀学期第 1 ⾄ 18 周⽬录实验题⽬:稀疏矩阵的运算 (3)⼀:概述 (3)⼆:系统分析 (3)三:概要设计 (3)四:详细设计 (4)五:运⾏与测试 (9)六:总结与⼼得 (9)实验题⽬:稀疏矩阵的运算⼀:概述本实验设计主要实现在⼗字链表存储结构输⼊稀疏矩阵,并对稀疏矩阵进⾏相加操作,最后输出运算结果。

⼆:系统分析本实验要求设计函数在⼗字链表结构下建⽴稀疏矩阵并初始化,在创建稀疏矩阵时,需要设计在⼗字链表下创建稀疏矩阵,在输⼊出现错误时,能够对错误进⾏判别处理,初始化稀疏矩阵都为空值。

在设计输出稀疏矩阵的值的函数时,根据情况编制函数,才能准确的输出稀疏矩阵。

在对稀疏矩阵进⾏初始化时,只输⼊⾮零元素的值和它所在的所在⾏及所在列。

在对稀疏矩阵输出时,以矩阵的完整形式输出。

除此之外还要求设计相加对两个矩阵进⾏运算,并输出最终的稀疏矩阵,定义相应的矩阵类型⽤于存放两个矩阵操作后的结果矩阵,这个结果矩阵的⾏、列数需要综合多⽅⾯情况来确定。

这些函数也是整个程序的难点,需要灵活运⽤数组及指针的特点。

三:概要设计⼗字链表结构体定义:typedef struct sex{int row,col,val; //⾮零元素的⾏、列下标及值struct sex *right,*dowm; //该⾮零元素所在⾏表和列表的后继元素}Node;矩阵的加法:此功能在⼗字链表存储结构下,由函数void addition(Node *cp1, Node *cp2, Node *cp3)实现。

当⽤户选择该功能,系统即提⽰⽤户初始化要进⾏加法的两个矩阵的信息。

然后进⾏加法,最后输出结果。

四:详细设计#include#includetypedef struct sex{int row,col,val; //⾮零元素的⾏、列下标及值struct sex *right,*dowm; //该⾮零元素所在⾏表和列表的后继元素}Node;Node * Init(int m, int n){int t,i;Node *cp;t=(m>=n)?m:n;cp=(Node *)malloc( (t+1)*sizeof(Node) ); //开辟⼀串连续的内存空间(*cp).row=m;(*cp).col=n;(*cp).val=t; //此表头结点的值域⽤来记录⾏列的最⼤值,以便于后⾯的开辟空间for(i=1;i<=t;i++){cp[i].right=cp+i;cp[i].dowm=cp+i; //构成带表头结点的空循环单链表}return cp;}void CreatCrossList(Node *cp){int t,i;Node *s,*temp;printf("请输⼊⾮零元素的个数N:");scanf("%d",&t);printf("\n请输⼊其对应坐标及元素值:\n");for(i=0;i{s=(Node *)malloc( sizeof(Node));scanf("%d%d%d",&s->row,&(*s).col,&s->val);temp=cp+s->row;if( temp->right!=cp+s->row )while( temp->right!=cp+s->row && temp->right->col<=s->col )temp=temp->right;s->right=temp->right;temp->right=s; //修改⾏链表插⼊位置temp=cp+s->col;if( temp->dowm!=cp+s->col )while( temp->dowm!=cp+s->col && temp->dowm->row<=s->row )temp=temp->dowm;s->dowm=temp->dowm;temp->dowm=s; //修改列链表插⼊位置}}void output(Node *cp){int i;Node *temp;printf("\n稀疏矩阵如下:\n");for(i=1;i<=cp->row;i++){temp=cp+i;while( temp->right!=cp+i ){printf("(%d,%d %d)",temp->right->row,temp->right->col,temp->right->val); temp=temp->right;}printf("\n");}}void Insert(Node *cp, Node *s){//此插⼊函数的作⽤是:⽣成⽬标矩阵Node *temp;temp=cp+s->row; //修改⾏链表指针if( temp->right!=cp+s->row )while( temp->right!=cp+s->row && temp->right->col<=s->col ) temp=temp->right;s->right=temp->right;temp->right=s;temp=cp+s->col; //修改列链表指针if( temp->dowm!=cp+s->col )while( temp->dowm!=cp+s->col && temp->dowm->row<=s->row ) temp=temp->dowm;s->dowm=temp->dowm;temp->dowm=s;}void addition(Node *cp1, Node *cp2, Node *cp3){int i;Node *w,*p,*q;for( i=1; i<=cp2->row && i<=cp3->row; i++){p=cp2+i;q=cp3+i;while( p->right!=cp2+i && q->right!=cp3+i ){w=(Node *)malloc( sizeof(Node) );w->row=p->right->row;if( p->right->col==q->right->col ){w->col=p->right->col;w->val=p->right->val+q->right->val; //相同位置上的元素值相加p=p->right;q=q->right;if( w->val )Insert(cp1,w); //把⾮零元插⼊到⽬标矩阵中}else if( p->right->colright->col ){w->col=p->right->col;w->val=p->right->val;p=p->right;Insert(cp1,w); //把cp2中的⾮零元插⼊到⽬标矩阵中}else{w->col=q->right->col;w->val=q->right->val;q=q->right;Insert(cp1,w); //把cp2中的⾮零元插⼊到⽬标矩阵中}}if( p->right==cp2+i )while( q->right!=cp3+i ){w=(Node *)malloc( sizeof(Node) );w->row=q->right->row;w->col=q->right->col;w->val=q->right->val;q=q->right;Insert(cp1,w); //把cp3中剩余的⾮零元插⼊⽬标矩阵中} else if( q->right==cp3+i )while( p->right!=cp2+i ){w=(Node *)malloc( sizeof(Node) );w->row=p->right->row;w->col=p->right->col;w->val=p->right->val;p=p->right;Insert(cp1,w); //把cp2中剩余的⾮零元插⼊到⽬标矩阵中} else; //两个矩阵同⼀⾏中同时结束}if( i>cp2->row)while(i<=cp3->row){//把cp3中剩余⾏中的⾮零元插⼊到⽬标矩阵中q=cp3+i;while( q->right!=cp3+i ){w=(Node *)malloc( sizeof(Node) );w->row=q->right->row;w->col=q->right->col;w->val=q->right->val;q=q->right;Insert(cp1,w);}i++; //继续下⼀⾏}else if(i>cp3->row)while( i<=cp2->row ){p=cp2+i;while( p->right!=cp2+i ){w=(Node *)malloc( sizeof(Node) );w->row=p->right->row;w->col=p->right->col;w->val=p->right->val;p=p->right;Insert(cp1,w);}i++; //继续下⼀⾏}}int main(){Node *cp1, *cp2, *cp3;int a, b;printf("\t\t\t*****稀疏矩阵的加法*****\n\n");printf("请输⼊cp2的⾏、列数:");scanf("%d%d",&a,&b);cp2=Init(a,b);printf("请输⼊cp3的⾏、列数:");scanf("%d%d",&a,&b);cp3=Init(a,b);a=cp2->row>=cp3->row?cp2->row:cp3->row;b=cp2->col>=cp3->col?cp2->col:cp3->col;cp1=Init(a,b); //开始初始化结果矩阵printf("\n\t>>>>>>>创建稀疏矩阵cp2\n");CreatCrossList(cp2);printf("\n\t>>>>>>>创建稀疏矩阵cp3\n");CreatCrossList(cp3);output(cp2);output(cp3);addition(cp1,cp2,cp3);printf("\n\n相加后的"); output(cp1);return 0;}五:运⾏与测试进⾏数据测试六:总结与⼼得⼗字链表作为存储结构表⽰随机稀疏矩阵,进⾏两矩阵的相加运算,所以⾸先要定义⼀个⼗字链表作为存储结构。

稀疏矩阵数据结构实验报告

稀疏矩阵数据结构实验报告

目录1.需求分析 (1)2.概要设计 (2)2.1链表对稀疏矩阵进行定义 (2)2.3程序一共有五个功能 (2)3.详细设计 (3)3.1稀疏矩阵存储算法分析 (3)3.2稀疏矩阵各运算算法分析 (3)4.调试分析 (8)4.1调试过程中的问题及解决方法 (8)4.2算法的时间复杂度和空间复杂 (8)4.3经验和体会 (8)5.用户使用说明 (9)6.测试结果 (10)6.1程序主界面 (10)6.2其他函数操作界面显示 (10)参考文献 (15)致谢 (16)1.需求分析矩阵在日常生活中应用广泛,尤其是有些特殊矩阵的运算。

但是在实际应用中有一种矩阵,在m×n的矩阵中有t个非零元素,且t远小于m×n,我们这样的矩阵被称为稀疏矩阵。

由于这类矩阵中通常零元素是没有规律的,为了能够找到相应的元素,仅存储非零元素的值是不行的,还要存储其所在的行和列等信息。

本程序主要的任务是创建稀疏矩阵,并且利用C++算法程序实现相应的运算(转置,加法,减法,乘法)(1)输入的形式以及范围:键盘输入符合要求的稀疏矩阵。

(2)输出形式:最终运算结果以矩阵的形式输出。

(3)程序功能实现:输入矩阵通过程序运算出相应的转置矩阵以及两个符合要求的矩阵的加减乘除法的运算。

(4)测试数据:如果输入正确,程序会显示最后的运算结果;否则错误时则会返回上层。

2.概要设计要存储稀疏矩阵并且进行运算,那么就要了解稀疏矩阵的存储结构,这里采用链表的形式存储稀疏矩阵并进行运算。

2.1链表对稀疏矩阵进行定义typedef struct OLNode{ // 定义链表元素int i,j;int e;struct OLNode *next; // 该非零元所在行表和列表的后继元素}OLNode,*OLink;typedef struct{ // 定义链表对象结构体OLink *head; //头指针int mu,nu,tu; // 行数,列数,和非零元素个数}CrossList;2.3程序一共有五个功能1.用CreateSMatrix_OL(M)函数来实现稀疏矩阵的存储,用OutPutSMatrix_OL(M)函数实现稀疏矩阵的输出。

数据结构实验报告稀疏矩阵运算

数据结构实验报告稀疏矩阵运算

数据结构实验报告稀疏矩阵运算实验目的:1.学习并理解稀疏矩阵的概念、特点以及存储方式。

2.掌握稀疏矩阵加法、乘法运算的基本思想和算法。

3.实现稀疏矩阵加法、乘法的算法,并进行性能测试和分析。

实验原理:稀疏矩阵是指矩阵中绝大多数元素为0的矩阵。

在实际问题中,有许多矩阵具有稀疏性,例如文本矩阵、图像矩阵等。

由于存储稀疏矩阵时,对于大量的零元素进行存储是一种浪费空间的行为,因此需要采用一种特殊的存储方式。

常见的稀疏矩阵的存储方式有三元组顺序表、十字链表、行逻辑链接表等。

其中,三元组顺序表是最简单直观的一种方式,它是将非零元素按行优先的顺序存储起来,每个元素由三个参数组成:行号、列号和元素值。

此外,还需要记录稀疏矩阵的行数、列数和非零元素个数。

稀疏矩阵加法的原理是将两个稀疏矩阵按照相同的行、列顺序进行遍历,对于相同位置的元素进行相加,得到结果矩阵。

稀疏矩阵乘法的原理是将两个稀疏矩阵按照乘法的定义进行计算,即行乘以列的和。

实验步骤:1.实现稀疏矩阵的三元组顺序表存储方式,并完成稀疏矩阵的初始化、转置、打印等基本操作。

2.实现稀疏矩阵的加法运算,并进行性能测试和分析。

3.实现稀疏矩阵的乘法运算,并进行性能测试和分析。

4.编写实验报告。

实验结果:经过实验测试,稀疏矩阵的加法和乘法算法都能正确运行,并且在处理稀疏矩阵时能够有效节省存储空间。

性能测试结果表明,稀疏矩阵加法、乘法的运行时间与非零元素个数有关,当非零元素个数较少时,运算速度较快;当非零元素个数较多时,运算速度较慢。

实验分析:稀疏矩阵的运算相对于普通矩阵的运算有明显的优势,可以节省存储空间和运算时间。

在实际应用中,稀疏矩阵的存储方式和运算算法都可以进行优化。

例如,可以采用行逻辑链接表的方式存储稀疏矩阵,进一步减少存储空间的占用;可以采用并行计算的策略加快稀疏矩阵的运算速度。

总结:通过本次实验,我深入学习了稀疏矩阵的概念、特点和存储方式,掌握了稀疏矩阵加法、乘法的基本思想和算法,并通过实验实现了稀疏矩阵的加法、乘法运算。

稀疏矩阵编程实验报告

稀疏矩阵编程实验报告

一、实验目的1. 理解稀疏矩阵的概念及其存储方式。

2. 掌握稀疏矩阵的基本操作,包括转置、加法、减法和乘法。

3. 通过编程实践,提高对数据结构和算法的理解和应用能力。

二、实验环境1. 编程语言:C语言2. 开发环境:Visual Studio 20193. 操作系统:Windows 10三、实验内容1. 稀疏矩阵的三元组表示及其实现2. 稀疏矩阵的转置3. 稀疏矩阵的加法、减法和乘法四、实验步骤1. 稀疏矩阵的三元组表示及其实现(1)定义稀疏矩阵的三元组结构体:```ctypedef struct {int row; // 行号int col; // 列号double val; // 非零元素值} Triple;```(2)定义稀疏矩阵结构体:typedef struct {int rows; // 矩阵行数int cols; // 矩阵列数int nums; // 非零元素个数Triple data; // 非零元素的三元组数组} SparseMatrix;```(3)编写函数实现稀疏矩阵的创建:```cvoid createSparseMatrix(SparseMatrix sm, int rows, int cols, int nums) { sm->rows = rows;sm->cols = cols;sm->nums = nums;sm->data = (Triple )malloc(nums sizeof(Triple));}```(4)编写函数实现稀疏矩阵的销毁:```cvoid destroySparseMatrix(SparseMatrix sm) {free(sm->data);sm->data = NULL;}2. 稀疏矩阵的转置(1)编写函数实现稀疏矩阵的转置:```cvoid transposeSparseMatrix(SparseMatrix src, SparseMatrix dst) {dst->rows = src->cols;dst->cols = src->rows;dst->nums = src->nums;dst->data = (Triple )malloc(src->nums sizeof(Triple));for (int i = 0; i < src->nums; i++) {dst->data[i].row = src->data[i].col;dst->data[i].col = src->data[i].row;dst->data[i].val = src->data[i].val;}}```3. 稀疏矩阵的加法、减法和乘法(1)编写函数实现稀疏矩阵的加法:```cvoid addSparseMatrix(SparseMatrix sm1, SparseMatrix sm2, SparseMatrix result) {result->rows = sm1->rows;result->cols = sm1->cols;result->nums = 0;for (int i = 0; i < sm1->nums; i++) {for (int j = 0; j < sm2->nums; j++) {if (sm1->data[i].row == sm2->data[j].row && sm1->data[i].col == sm2->data[j].col) {if (sm1->data[i].val + sm2->data[j].val != 0) {result->data[result->nums++] = sm1->data[i];result->data[result->nums - 1].val += sm2->data[j].val;}}}}}```(2)编写函数实现稀疏矩阵的减法:```cvoid subSparseMatrix(SparseMatrix sm1, SparseMatrix sm2, SparseMatrix result) {result->rows = sm1->rows;result->cols = sm1->cols;result->nums = 0;for (int i = 0; i < sm1->nums; i++) {for (int j = 0; j < sm2->nums; j++) {if (sm1->data[i].row == sm2->data[j].row && sm1->data[i].col == sm2->data[j].col) {if (sm1->data[i].val - sm2->data[j].val != 0) {result->data[result->nums++] = sm1->data[i];result->data[result->nums - 1].val -= sm2->data[j].val;}}}}}```(3)编写函数实现稀疏矩阵的乘法:```cvoid mulSparseMatrix(SparseMatrix sm1, SparseMatrix sm2, SparseMatrix result) {result->rows = sm1->rows;result->cols = sm2->cols;result->nums = 0;for (int i = 0; i < sm1->nums; i++) {for (int j = 0; j < sm2->nums; j++) {if (sm1->data[i].col == sm2->data[j].row) {double sum = 0;for (int k = 0; k < sm1->nums; k++) {if (sm1->data[k].col == sm2->data[j].row) {sum += sm1->data[k].val sm2->data[j].val;}}if (sum != 0) {result->data[result->nums++] = sm1->data[i];result->data[result->nums - 1].val = sum;}}}}}```五、实验结果与分析1. 通过编程实现稀疏矩阵的基本操作,验证了算法的正确性。

稀疏矩阵实验报告

稀疏矩阵实验报告

稀疏矩阵基本操作班级:计算机科学与技术(2)班小组成员:日期:2012年4月17日1.需求分析【实验目的】熟悉抽象数据类型的表示和实现方法。

抽象数据类型需借助固有数据类型来表示和实现,及利用高级程序设计语言中已存在的数据类型来说明新的结构,用已经实现的操作来组合新的操作,具体实现细节则依赖于所用的语言的功能。

通过本次实习还可以帮助读者复习高级语言的使用方法。

掌握数组的特点及基本操作,如存储、输出、乘积、转置等,,以便在实际问题背景下灵活应用。

【基本要求】1.用C++/C完成算法设计和程序设计并上机调试通过。

2.撰写实验报告,提供实验结果和数据。

3.分析算法,要求给出具体的算法分析结果,包括时间复杂度和空间复杂度,并简要给出算法设计小结和心得。

2.概要设计栈的抽象数据类型ADT Matrix {数据对象:D={aij| i=1,2,…,m;j=1,2,…,n;ai∈ElemSet,m 、n分别称为矩阵的行数和列数}数据关系:R={Row,Col}Row={<ai.j,ai.j+1>|1<=i<=m,1<=j<=n-1}Col={<ai.j,ai+1,j|1<=i<=m-1,1<=j<=n}基本操作:CreatSMatrix(&M)操作结果:构造一个稀疏矩阵。

Destroy SMatix (&M)初始条件:稀疏矩阵M已存在。

操作结果:销毁稀疏矩阵M。

PrintSMtrix(&M)初始条件:稀疏矩阵已存在。

操作结果:输出稀疏矩阵M。

CompSMtrix(M,&T)初始条件:稀疏矩阵M已存在。

操作结果:由稀疏矩阵M复制得到T。

AddSMtrix(M,N,&Q)初始条件:稀疏矩阵M和N的行数与列数相等。

操作结果:求稀疏矩阵的和Q=M+N。

SubtMtrix(M,N,&Q)初始条件:稀疏矩阵M和N的行数与列数对应相等。

数据结构实验报告稀疏矩阵运算

数据结构实验报告稀疏矩阵运算

教学单位计算机科学与技术学生学号************数据结构课程设计报告书题目稀疏矩阵运算器学生姓名秦豹专业名称软件工程指导教师李志敏实验目的:深入研究数组的存储表示和实现技术,熟悉广义表存储结构的特性。

需要分析:稀疏矩阵是指那些多数元素为零的矩阵。

利用“稀疏”特点进行存储和计算可以大大节省存储空间,提高计算效率。

实现一个能进行稀疏矩阵基本运算的运算器。

要求以带“行逻辑链接信息”的三元组顺序表存储稀疏矩阵,实现两矩阵的相加、相减、相乘等运算。

输入以三元组表示,输出以通常的阵列形式列出。

软件平台:Windows 2000,Visual C++6.0或WINTC概要设计:ADT Array {数据对象:D = {aij | 0≤i≤b1-1, 0 ≤j≤b2-1}数据关系:R = { ROW, COL }ROW = {<ai,j,ai+1,j>| 0≤i≤b1-2, 0≤j≤b2-1}COL = {<ai,j,ai,j+1>| 0≤i≤b1-1, 0≤j≤b2-2}基本操作:CreateSMatrix(&M); //操作结果:创建稀疏矩阵M.Print SMatrix(M);//初始化条件: 稀疏矩阵M存在.//操作结果:输出稀疏矩阵M.AddSMatrix(M,N,&Q);//初始化条件: 稀疏矩阵M与N的行数和列数对应相等.//操作结果:求稀疏矩阵的和Q=M+N.SubSMatrix(M,N,&Q);//初始化条件: 稀疏矩阵M与N的行数和列数对应相等.//操作结果:求稀疏矩阵的差Q=M-N.MultSMatrix(M,N,&Q);//初始化条件: 稀疏矩阵M的列数等于N的行数.//操作结果:求稀疏矩阵的乘积Q=M*N.} ADT Array调试测试:初始界面矩阵的加法矩阵的减法矩阵的转置矩阵的乘法程序源码:#include<stdio.h>#include<malloc.h>#include<stdlib.h>#define MAXSIZE 40 //假设非零元素个数的最大值为40#define MAXRC 20 //假设矩阵的最大行数为20typedef int ElemType;typedef struct{int i,j; //非零元的行下标和列下标ElemType e; //非零元的值}Triple;typedef struct{Triple data[MAXSIZE+1];int rpos[MAXRC+1]; //各行第一个非零元在三元组的位置表int hs,ls,fls;}TSMatrix,*Matrix;void Creat(TSMatrix &M){int i,k;for(i=1;i<=MAXRC+1;i++)M.rpos[i]=0;printf("请输入矩阵的行数、列数和非零元个数(以空格隔开):");scanf("%d %d %d",&M.hs,&M.ls,&M.fls);for(i=1;i<=M.fls;i++){printf("请用三元组形式输入矩阵的元素(行列非零元素):");scanf("%d %d %d",&M.data[i].i,&M.data[i].j,&M.data[i].e);}for(i=1,k=1;i<=M.hs;i++){M.rpos[i]=k;while(M.data[k].i<=i && k<=M.fls)k++;}}void Xiangjia(TSMatrix A,TSMatrix B,TSMatrix &C,int n){int a,b,temp,l;C.hs=A.hs;C.ls=A.ls;a=b=l=1;while(a<=A.fls && b<=B.fls){if(A.data[a].i==B.data[b].i){if(A.data[a].j<B.data[b].j)C.data[l++]=A.data[a++];else if(A.data[a].j>B.data[b].j){C.data[l]=B.data[b]; C.data[l++].e=n*B.data[b++].e;}else{temp=A.data[a].e+n*B.data[b].e;if(temp){C.data[l]=A.data[a];C.data[l].e=temp;l++;}a++;b++;}}else if(A.data[a].i<B.data[b].i)C.data[l++]=A.data[a++];else {C.data[l]=B.data[b]; C.data[l++].e=n*B.data[b++].e;} }while(a<=A.fls)C.data[l++]=A.data[a++];while(b<=B.fls){C.data[l]=B.data[b]; C.data[l++].e=n*B.data[b++].e;}C.fls=l-1;}int Xiangcheng(TSMatrix A,TSMatrix B,TSMatrix &Q){int arow,brow,ccol,tp,p,q,t;int ctemp[MAXRC+1];if(A.ls!=B.hs) return 0;Q.hs=A.hs;Q.ls=B.ls;Q.fls=0;if(A.fls*B.fls){for(arow=1;arow<=A.hs;arow++){for(ccol=1;ccol<=Q.ls;ccol++)ctemp[ccol]=0;Q.rpos[arow]=Q.fls+1;if(arow<A.hs) tp=A.rpos[arow+1];else tp=A.fls+1;for(p=A.rpos[arow];p<tp;p++){brow=A.data[p].j;if(brow<B.hs) t=B.rpos[brow+1];else t=B.fls+1;for(q=B.rpos[brow];q<t;q++){ccol=B.data[q].j;ctemp[ccol]+=A.data[p].e*B.data[q].e;}}for(ccol=1;ccol<=Q.ls;ccol++){if(ctemp[ccol]){if(++Q.fls>MAXSIZE) return 0;Q.data[Q.fls].i=arow;Q.data[Q.fls].j=ccol;Q.data[Q.fls].e=ctemp[ccol];}}}}return 1;}void Print_SMatrix(TSMatrix M){int k,l,n;Matrix p;p=&M;for(k=1,n=1;k<=p->hs;k++){for(l=1;l<=p->ls;l++){if(p->data[n].i==k && p->data[n].j==l){printf("%5d",p->data[n].e);n++;}elseprintf("%5d",0);}printf("\n");}printf("\n");}void Zhuanzhi(TSMatrix *a,TSMatrix *b){int q,col,p;b->hs=a->ls;b->ls=a->hs;b->fls=a->fls;if(b->fls){q=1;for(col=1;col<=a->ls;col++)for(p=1;p<=a->fls;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;}}}void Destory_SMatrix(TSMatrix &M){M.hs=M.ls=M.fls=0;}void main(){TSMatrix A,B,C;TSMatrix *p=&A,*q=&B;int flag,n;while(1){system("cls");printf("\n\n\n");printf("\t┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n");printf("\t┃*** 稀疏矩阵的加、减、转、乘*** ┃\n");printf("\t┣━━━━━━━━━━━━━━━━━━━━━━━━━━━┫\n");printf("\t┃1、稀疏矩阵的加法┃\n");printf("\t┃2、稀疏矩阵的减法┃\n");printf("\t┃3、稀疏矩阵的转置┃\n");printf("\t┃4、稀疏矩阵的乘法┃\n");printf("\t┃5、退出该应用程序┃\n");printf("\t┗━━━━━━━━━━━━━━━━━━━━━━━━━━━┛\n");printf("输入要进行的项目的编号:");scanf("%d",&flag);if(flag==5) break;Creat(A);printf("矩阵A:\n"); Print_SMatrix(A);switch(flag){case 1: Creat(B);n=1;printf("矩阵B:\n");Print_SMatrix(B);if(A.hs==B.hs && A.ls==B.ls){printf("A+B:\n");Xiangjia(A,B,C,n);Print_SMatrix(C);}else printf("错误!行列不一致\n");break;case 2: Creat(B);n=-1;printf("矩阵B:\n");Print_SMatrix(B);if(A.hs==B.hs && A.ls==B.ls){printf("A-B:\n");Xiangjia(A,B,C,n);Print_SMatrix(C);}else printf("错误!行列不一致\n");break;case 3: printf("A->B:\n");Zhuanzhi(p,q);Print_SMatrix(B);break;case 4: Creat(B);printf("矩阵B:\n");Print_SMatrix(B);printf("A*B:\n");n=Xiangcheng(A,B,C);if(!n) printf("错误!行列不匹配\n");else Print_SMatrix(C);break;default: printf("输入错误!\n");}Destory_SMatrix(A);Destory_SMatrix(B);Destory_SMatrix(C);getchar();getchar();}printf("\n\t\t\t ***程序已经退出***\n");getchar();}小结:。

《数据结构 课程设计》稀疏矩阵实验报告

《数据结构 课程设计》稀疏矩阵实验报告

(2)稀疏矩阵的相加:
void MatrixAdd(int A[max],int B[max],int C[max]),这个函数用 于实现数组A和数组B的相加,并将其相加的结果存入数组C。这个函数 讨论了数组在相加的过程中的几种情况: a、 A数组和B数组的行相等且列相等,两者直接相加后存入数组C中。 if(A[i]==B[j]) { if(A[i+1]==B[j+1]) { C[k]=A[i]; C[k+1]=A[i+1]; C[k+2]=A[i+2]+B[j+2]; k=k+3; i=i+3; j=j+3; } } b、A的列小于B的列,将A的三个元素直接存入C中
2、 系统分析
稀疏矩阵的保存:以一位数组顺序存放非零元素的行号、列号和数 值,行号为-1作为结束符。以三个一维数组存放一个系数矩阵中的一个 非零元素,为零额元素则不保存。用一个二重循环来实现判断每个系数
矩阵的非零元素是否为零,不为零,就将其行列下标和其值存入一维数 组中 稀疏矩阵的相加:用循环来判断存储A何B稀疏矩阵的两个一维数组 中的行列下标是否相等和其大小关系。若相等,则将两个一维数组的第 三个元素的值相加存入新的数组C里,行列下标不变的存入进去;若A的 列小于B的列,则将A的三个元素直接存入C中;若B的列小于A的列,则 将B的三个元素村日C中;若A的行小于B的行,则将A的三个元素存入C 中;若A的行大于B的行,则将B存入C中。
3、 概要设计
(1)主界面的设计:
定义两个矩阵a= 0 0 0 0 0 0 0 0 0 0 0 9 3 0 0 0 0 0 0 0 0 0 0 0 0 0 0 7 0 0 0 0 0 0 0 0 0 5 0 0 0 0 0 0 0 0 0 0 b= 0 0 0 0 0 0 2 0 0 0 0 0 0 0 0 0 1 0 0 4 0 0 0 0 0 0 0 8 0 0 0 0 6 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

数据结构_基于三元组表的存储结构实现稀疏矩阵的应用__课程设计_实验报告

数据结构_基于三元组表的存储结构实现稀疏矩阵的应用__课程设计_实验报告
1
2.4 退出系统 本模块要求设置选项能随时结束程序的运行,本程序中采用 do-while 循环。
程序在计算机上显示“提示信息”之后,由用户在键盘上输入演示程序中需要的 相关信息及命令。
三、项目设计 3.1 结构设计
1、以“带行逻辑链接信息”的三元组顺序表表示稀疏矩阵,实现两个矩阵 相加、相减和相乘的运算
一、课题设计目的及意义 1.1、课题设计目的 (1)掌握稀疏矩阵三元组表的存储,创建,显示,转置等方法。 (2)利用三元组表实现矩阵的相加,减。 (3)了解稀疏矩阵的相关应用。
1.2、课程设计意义 本次课题设计可以使我们更熟练的掌握有关三元组表及稀疏矩阵的相关知
识,比一般存储方法节省了存储空间,基于三元组表的存储结构实现了稀疏矩阵 的基本操作。
本次课程设计是本组成员共同努力而完成的,第一次进行课程设计是我们的 探索过程,这个过程中,我们克服了一个个困难,在摸索中前行,我们相信通过 此次课程设计我们每个人都会对数据结构这门课程有更深一步的了解。
二、需求分析 稀疏矩阵是指那些多数元素为零的矩阵。利用“稀疏”特点进行存储和计
算可以大大节省存储空间,提高计算效率。实现一个能进行稀疏矩阵基本运算的 运算器。以“带行逻辑链接信息”的三元组顺序表表示稀疏矩阵,实现两个矩阵 相加、相减和相乘的运算。稀疏矩阵的输入形式采用三元组表示,而运算结果的 矩阵则通常以阵列形式列出。 2.1 设计函数建立稀疏矩阵及初始化值和输出稀疏矩阵的值
六、实验总结............................................................................................................ 10 七 、 附 录 .....................................................................................................................11

稀疏矩阵实验报告(包括问题描述,源代码,实验结果等)

稀疏矩阵实验报告(包括问题描述,源代码,实验结果等)

数据结构课程设计实习报告题目:班级:学号:姓名:实习报告1.问题描述稀疏矩阵的操作基本功能要求:(1)稀疏矩阵采用三元组表示,求两个具有相同行列数的稀疏矩阵A和B的相加矩阵C,并输出C。

(2)求出A的转置矩阵D,输出D。

2.设计1)设计思想矩阵中如果多数的元素没有数据,则会造成存储器空间的浪费,为此,必须设计稀疏矩阵的阵列储存方式,利用较少的存储器空间储存完整的矩阵数据。

但是这些存储空间的大部分存放的是0元素,从而造成大量的空间浪费.为了节省存储空间,可以只存储其中的非0元素. 对于矩阵Amn的每个元素aij,知道其行号i 和列号j就可以确定其位置.因此对于稀疏矩阵可以用一个结点来存储一个非0元素.该结点可以定义成: [i,j,aij]创建一个矩阵A和矩阵B,这两个稀疏矩阵具有相同行列数,然后矩阵A与矩阵B相加得到矩阵C,并输出C,稀疏矩阵采用三元组表示。

并调用原矩阵A 转置得到矩阵D,输出D。

2) 设计表示法(1) 函数调用关系如图所示。

3)实现注释:实现了原题中要求的:两个具有相同行列数的稀疏矩阵A和B的相加矩阵C,并输出C;得到矩阵A的转置矩阵D,输出D;稀疏矩阵均采用三元组表示。

3.调试报告调试程序时,应注意矩阵的调用。

比如,开始的时候没有注意将程序调用,最后尽管实现了矩阵的转置和相加,但没有符合题意。

题目要求的是用创建好的矩阵A和矩阵B进行相加,并对矩阵A进行转置,所以要调用好矩阵。

4.程序清单#include<stdio.h>#include<stdlib.h>#define MAXSIZE 100typedef struct{int i,j;int e;}Triple;typedef struct{Triple data[MAXSIZE+1];int mu,nu,tu; //mu、nu为稀疏矩阵的行列数,tu为稀疏矩阵的非零元素个数}TSMatrix;TSMatrix M,T,S,B,C;void CreateMatrix(TSMatrix &M){int i,elem,col,row,mu,nu,tu;printf("请输入稀疏矩阵的行数、列数和非零元素的个数:\n");scanf("%d%d%d",&mu,&nu,&tu);M.mu=mu;M.nu=nu;M.tu=tu;for (i=1;i<=tu;i++){printf("请输入非零元素的行号、列号和值:\n");scanf("%d%d%d",&col,&row,&elem);if ( mu<=1 || col>M.mu ||nu<=1 || row>M.nu){printf("error!");exit(0);}else{M.data[i].i=col; //输出这个三元组M.data[i].j=row;M.data[i].e=elem;}}}void FastTransposeSMatrix(TSMatrix M) /*求转置矩阵*/ {int num[100];int cpot[100];int p,q,t,col=0;T.mu=M.nu; // 给T的行、列数与非零元素个数赋值T.nu=M.mu;T.tu=M.tu;if(T.tu){for(col=1;col<=M.nu;col++){num[col]=0;}for(t=1;t<=M.tu;t++){num[M.data[t].j]++;}cpot[1]=1;for(col=2;col<=M.nu;col++){cpot[col]=cpot[col-1]+num[col-1];}for(p=1;p<=M.tu;++p){col=M.data[p].j;q=cpot[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;cpot[col]++;}} TSMatrix(T);}void TSMatrix_add(TSMatrix M,TSMatrix T,TSMatrix &ADD) /*求矩阵的和*/ {int a=1,b=1,c=1,x;ADD.mu=M.mu;ADD.nu=M.nu;ADD.tu=0;for(x=1;x<=M.mu;x++){while(M.data[a].i==x&&T.data[b].i==x){if(M.data[a].j==T.data[b].j){ADD.data[c].i=M.data[a].i;ADD.data[c].j=M.data[a].j;ADD.data[c].e=M.data[a].e+T.data[b].e;c++;a++;b++;}else if(M.data[a].j<T.data[b].j){ADD.data[c].i=M.data[a].i;ADD.data[c].j=M.data[a].j;ADD.data[c].e=M.data[a].e;c++;a++;}else{ADD.data[c].i=T.data[b].i;ADD.data[c].j=T.data[b].j;ADD.data[c].e=T.data[b].e;c++;b++;}}while(M.data[a].i==x){ADD.data[c].i=M.data[a].i;ADD.data[c].j=M.data[a].j;ADD.data[c].e=M.data[a].e;c++;a++;while(T.data[b].i==x){ADD.data[c].i=T.data[b].i;ADD.data[c].j=T.data[b].j;ADD.data[c].e=T.data[b].e;c++;b++;}}ADD.tu=c-1;}void ShowMatrix(TSMatrix &M) /*打印出矩阵*/ {int i=1,j=1,dir=1;//printf("稀疏矩阵为:\n");for(i=1;i<=M.mu;i++){for(j=1;j<=M.nu;j++){if(M.data[dir].i==i && M.data[dir].j==j) {printf("%d ",M.data[dir].e);dir++;}elseprintf("0 ");}printf("\n");}void main(){while(1){int c;M.mu=0;M.nu=0;M.tu=0;printf("1.创建一个稀疏矩阵A:\n");printf("2.求转置矩阵A:\n");printf("3.创建一个稀疏矩阵B:\n");printf("4.求转置矩阵B:\n");printf("5.求A与B原矩阵的和:\n"); while (1){printf("请按键选择:");scanf("%d",&c);switch(c){case 1:CreateMatrix(M) ;break;case 2:FastTransposeSMatrix(M);printf("原矩阵A为:\n");ShowMatrix(M);printf("转置矩阵为:\n"); ShowMatrix(T);break;case 3:CreateMatrix(B) ;break;case 4:FastTransposeSMatrix(B);printf("原矩阵B为:\n");ShowMatrix(B);printf("转置矩阵为:\n");ShowMatrix(T);break;case 5:FastTransposeSMatrix(M);TSMatrix_add(M,B,S);printf("A与B原矩阵的和为:\n");ShowMatrix(S);break;return 0;}}}}5.结果分析(1)选择选项1,创建矩阵A;选择选项2,转置矩阵A。

课程设计实验报告 稀疏矩阵应用

课程设计实验报告 稀疏矩阵应用

数据结构课程设计《数据结构》课程设计一.题目:稀疏矩阵应用(限1 人完成)要求:实现三元组,十字链表下的稀疏矩阵的加、转、乘的实现。

(1)稀疏矩阵的存储(2)稀疏矩阵加法(3)矩阵乘法(4)矩阵转置二.算法思想描述:1.需求分析(1)设计函数建立稀疏矩阵,初始化值。

(2)设计函数输出稀疏矩阵的值。

(3)构造函数进行两个稀疏矩阵相加,输出最终的稀疏矩阵。

(4)构造函数进行两个稀疏矩阵的相乘,输出最终的稀疏矩阵。

(5)构造函数进行稀疏矩阵的转置,并输出结果。

(6)退出系统。

1.算法概述:首先用两个结构体来定义十字链表元素:typedef struct OLNode{int i,j;int e;struct OLNode *right,*down;}OLNode,*OLink;OLNode结构为链表结点,i,j,e分别表示稀疏矩阵中元素的行,列和值。

typedef struct {int mu,nu,tu; //行数mu,列数nu,非零元素的个数tuOLink *rhead,*chead;}CrossList;CrossList结构用于连接起各个结点,mu,nu,tu分别表示整个矩阵的行数列数和非零元素的个数。

整个程序包含CreateSMatix_OL(用于创建十字链表),SMatrix_ADD(十字链表相加),ShowMAtrix(十字链表显示),MultSMatrix_OL(十字链表相乘),TurnSMatrix_OL(十字链表转置),DestroySMatrix_OL(十字链表销毁)六个函数。

CreateSMatix_OL的功能如下:首先输入稀疏矩阵的行数,列数,非零元素的个数,为*rhead和*chead分配内存空间,并将十字链表中节点初始化为NULL。

然后依次输入非零元素的行,列,值,以0 0 0为结尾结束链表的连接和while循环。

SMatrix_ADD 的功能如下:在初始化稀疏矩阵后选择十字链表相加会提示输入另一个稀疏矩阵,连接结束后SMatrix_ADD 函数以循环的方式比较非零元素是否为同一行列,如果是则两值相加,如果不是则把第二个元素加入链表中。

《数据结构 课程设计》稀疏矩阵实验报告

《数据结构 课程设计》稀疏矩阵实验报告

目录一、概述 (1)二、系统分析 (1)三、概要设计 (1)(1)主界面的设计: (2)(2)系数矩阵的存储 (2)(3)具体实现流程图: (3)四、详细设计 (4)(2)稀疏矩阵的相加: (5)五、运行与测试 (8)六、总结与心得 (9)参考文献 (9)源代码 (9)一、概述稀疏矩阵的加法运算,既将稀疏矩阵A和B,他均为m行n列,分别以数组的形式存放在A和B中,实现A+B=C,将所得的结果存放在C数组中。

二、系统分析稀疏矩阵的保存:以一位数组顺序存放非零元素的行号、列号和数值,行号为-1作为结束符。

以三个一维数组存放一个系数矩阵中的一个非零元素,为零额元素则不保存。

用一个二重循环来实现判断每个系数矩阵的非零元素是否为零,不为零,就将其行列下标和其值存入一维数组中稀疏矩阵的相加:用循环来判断存储A何B稀疏矩阵的两个一维数组中的行列下标是否相等和其大小关系。

若相等,则将两个一维数组的第三个元素的值相加存入新的数组C里,行列下标不变的存入进去;若A的列小于B的列,则将A的三个元素直接存入C中;若B的列小于A的列,则将B的三个元素村日C中;若A的行小于B的行,则将A的三个元素存入C中;若A的行大于B的行,则将B存入C中。

三、概要设计(1)主界面的设计:定义两个矩阵a= 0 0 3 0 0 0 0 0 b= 0 2 0 0 0 0 0 00 0 0 0 0 0 5 0 0 0 0 4 0 0 0 00 0 0 0 0 0 0 0 0 0 0 0 0 6 0 00 0 0 0 7 0 0 0 0 0 0 0 8 0 0 00 0 0 0 0 0 0 0 0 0 1 0 0 0 0 00 9 0 0 0 0 0 0 0 0 0 0 0 0 0 0定义两个数组A和B,用于存储矩阵a和矩阵b的值;定义一个数组C,用于存放数组A和数组B相加后的结果。

(2)系数矩阵的存储用一维数组存放系数矩阵A如下:A[0]=0,A[1]=2, A[2]=3, A[3]=1, A[4]=6, A[5]=5, A[6]=3, A[7]=4, A[8]=7, A[9]=5, A[10]=1, A[11]=9, A[12]=-1。

稀疏矩阵实验报告

稀疏矩阵实验报告

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

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

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

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

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

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

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

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

- 实现稀疏矩阵的乘法。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

数据结构稀疏矩阵应用

数据结构稀疏矩阵应用

实验五数组的运算实验目的:掌握稀疏矩阵的压缩存储方法及主要运算的实现。

实验内容与要求:设计一个稀疏矩阵计算器,要求能够:⑴输入并建立稀疏矩阵;⑵输出稀疏矩阵;⑶执行两个矩阵相加;⑷求一个矩阵的转置矩阵。

程序代码:#include<stdio.h>#define smax 20typedef int datatype;typedef struct{ int i,j;datatype v;}node;typedef struct{ node data[smax];int m,n,t;}spmatrix;void creat(spmatrix a)\\创建输出稀疏矩阵{ int k=0;printf("请输入稀疏矩阵:\n");scanf("%d,%d,%d",&a.m,&a.n,&a.t);scanf("%d,%d,%d",&a.data[0].i,&a.data[0].j,&a.data[0].v);while(a.data[k].v!=0)\\以0元素作为结束标志,因为稀疏矩阵不包含0元素{k++;scanf("%d,%d,%d",&a.data[k].i,&a.data[k].j,&a.data[k].v);}printf("输出的稀疏矩阵是:\n");printf("%d,%d,%d\n",a.m,a.n,a.t);for(k=0;k<a.t;k++)\\一维数组思想,用for循环简单printf("%d,%d,%d\n",a.data[k].i,a.data[k].j,a.data[k].v);printf("\n");}void transpose(spmatrix a)\\转置函数{ int p,q,k=0;printf("请输入稀疏矩阵:\n");scanf("%d,%d,%d",&a.m,&a.n,&a.t);scanf("%d,%d,%d",&a.data[0].i,&a.data[0].j,&a.data[0].v);while(a.data[k].v!=0){k++;scanf("%d,%d,%d",&a.data[k].i,&a.data[k].j,&a.data[k].v);}for(k=0;k<a.t;k++)\\行列交换即可,但没有进行排序输出{p=a.data[k].i;a.data[k].i=a.data[k].j;a.data[k].j=p;}printf("输出转置后的初步矩阵元素:\n");for(k=0;k<a.t;k++)printf("%d,%d,%d\n",a.data[k].i,a.data[k].j,a.data[k].v);for(p=0;p<a.t;p++)\\冒泡排序法,对转置后的稀疏矩阵进行重新排序for(k=0;k<(a.t-p);k++){if(a.data[k].i>a.data[k+1].i || (a.data[k].i==a.data[k+1].i &&a.data[k].j>a.data[k+1].j)){q=a.data[k].i;a.data[k].i=a.data[k+1].i;a.data[k+1].i=q;q=a.data[k].j;a.data[k].j=a.data[k+1].j;a.data[k+1].j=q;q=a.data[k].v;a.data[k].v=a.data[k+1].v;a.data[k+1].v=q;}}printf("输出转置后的稀疏矩阵:\n");printf("%d,%d,%d\n",a.n,a.m,a.t);for(k=1;k<(a.t+1);k++)\\此处下标加1是根据输出结果判定而来,不知道原因printf("%d,%d,%d\n",a.data[k].i,a.data[k].j,a.data[k].v);printf("\n");}void add(spmatrix a,spmatrix b)\\求和函数{spmatrix c;int x=0,y=0,z=0;int p,q,r=0;printf("请输入稀疏矩阵a:\n");scanf("%d,%d,%d",&a.m,&a.n,&a.t);scanf("%d,%d,%d",&a.data[0].i,&a.data[0].j,&a.data[0].v);while(a.data[x].v!=0){x++;scanf("%d,%d,%d",&a.data[x].i,&a.data[x].j,&a.data[x].v);}printf("请输入稀疏矩阵b:\n");scanf("%d,%d,%d",&b.m,&b.n,&b.t);scanf("%d,%d,%d",&b.data[0].i,&b.data[0].j,&b.data[0].v);while(a.data[y].v!=0){y++;scanf("%d,%d,%d",&b.data[y].i,&b.data[y].j,&b.data[y].v);}\\以上为重新创建两个稀疏矩阵,方便运算if(a.m==b.m && a.n==b.n)\\首先行列相等的稀疏矩阵才能相加{for(x=0;x<a.t;x++){c.data[z].i=a.data[x].i;c.data[z].j=a.data[x].j;c.data[z].v=a.data[x].v;z++;}for(y=0;y<a.t;y++){c.data[z].i=b.data[y].i;c.data[z].j=b.data[y].j;c.data[z].v=b.data[y].v;z++;}\\两个for循环先后把a,b两个稀疏矩阵元素放到一个新的稀疏矩阵c里去printf("输出结合后的初步稀疏矩阵C的元素:\n");\\进行一次打印for(z=0;z<(a.t+b.t);z++)printf("%d,%d,%d\n",c.data[z].i,c.data[z].j,c.data[z].v);for(p=0;p<(a.t+b.t);p++)\\冒泡排序法对新矩阵元素排序for(z=0;z<(a.t+b.t-p);z++){if(c.data[z].i>c.data[z+1].i || (c.data[z].i==c.data[z+1].i &&c.data[z].j>c.data[z+1].j))\\有这几种情况需要重新排序,首先是进行行对比(前行大于后行进行交换),然后当行相等时在进行列对比(前列大于后列时在进行交换),其他情况均不用交换{q=c.data[z].i;c.data[z].i=c.data[z+1].i;c.data[z+1].i=q;q=c.data[z].j;c.data[z].j=c.data[z+1].j;c.data[z+1].j=q;q=c.data[z].v;c.data[z].v=c.data[z+1].v;c.data[z+1].v=q;}}printf("输出排序后的稀疏矩阵C的元素:\n");\\进行一次打印for(z=1;z<(a.t+b.t+1);z++)printf("%d,%d,%d\n",c.data[z].i,c.data[z].j,c.data[z].v);for(z=1;z<(a.t+b.t+1-r);z++)\\主循环,保证阅读每一个数组元素if(c.data[z].i==c.data[z+1].i && c.data[z].j==c.data[z+1].j) \\在对排好序后的矩阵进行相等行列元素的合并{c.data[z].v=c.data[z].v+c.data[z+1].v;r++;\\此处是关键,记录此时的步骤,如果进行一次运算后,那么后面的循环就要少一次,包括再回到主循环时也要少一次for(z+1;(z+1)<(a.t+b.t+1-r);z++)\\小循环是让后面的每一个数组元素向前移动一个位置,掩盖掉相等行列元素{c.data[z+1].i=c.data[z+2].i;c.data[z+1].j=c.data[z+2].j;c.data[z+1].v=c.data[z+2].j;}}printf("输出最终结果的稀疏矩阵C:\n");printf("%d,%d,%d\n",a.m,a.n,(a.t+b.t-r));\\输出稀疏矩阵表头时只需将行列元素交换输出即可,元素个数输出时要注意相等行列元素合并进行了几次操作,即用r记录操作步骤的次数,每进行一次操作那么最终稀疏矩阵就少一个数组元素,同时r又是伴随步骤增加的for(z=1;z<(a.t+b.t+1-r);z++)\\原理同上printf("%d,%d,%d\n",c.data[z].i,c.data[z].j,c.data[z].v);}Else\\给出稀疏矩阵表开头行列总和不等时则无法计算printf("输入的稀疏矩阵a,b不是行列相等的矩阵。

数据结构实验报告实验五稀疏矩阵运算器

数据结构实验报告实验五稀疏矩阵运算器

一、引言稀疏矩阵是一个具有大量零元素的矩阵,对于大规模的矩阵来说,如果没有充分利用矩阵的稀疏性质,将会带来很大的存储空间和计算时间上的浪费。

为了解决这个问题,我们需要通过设计一个稀疏矩阵运算器来对稀疏矩阵进行各种运算,以提高计算效率。

二、实验目标本实验的主要目标是设计一个稀疏矩阵运算器,通过实现对稀疏矩阵的加法、乘法和转置等操作,实现对稀疏矩阵的高效运算。

三、设计思路和方法1. 矩阵的表示方式在设计稀疏矩阵运算器时,我们需要选择合适的数据结构来表示稀疏矩阵。

由于稀疏矩阵中大部分元素为零,我们可以采用压缩存储的方法来表示稀疏矩阵。

一种常用的压缩存储方法是使用三元组表示法,即将矩阵的非零元素的值、所在的行号和列号分别存储在一个三元组中。

2. 加法运算稀疏矩阵的加法运算是指将两个稀疏矩阵进行对应位置的相加操作。

在进行稀疏矩阵的加法运算时,首先需要判断两个矩阵的维度是否相同,然后通过遍历两个矩阵的非零元素,将相同位置的元素进行相加得到结果。

3. 乘法运算稀疏矩阵的乘法运算是指将两个稀疏矩阵进行矩阵乘法操作。

在进行稀疏矩阵的乘法运算时,首先需要判断第一个矩阵的列数是否等于第二个矩阵的行数,然后通过遍历两个矩阵的非零元素,按照行和列的顺序对应相乘,再将相乘的结果加到结果矩阵中。

4. 转置运算稀疏矩阵的转置运算是指将矩阵的行和列对换。

在进行稀疏矩阵的转置运算时,只需要将矩阵的非零元素的行号和列号对换即可。

五、实验结果与分析我们在实现稀疏矩阵运算器后,对其进行了测试。

通过测试,我们发现稀疏矩阵运算器能够正确地进行稀疏矩阵的加法、乘法和。

稀疏矩阵的应用

稀疏矩阵的应用
{
ta[ta1->td].p=i;
ta[ta1->td].q=j;
ta[ta1->td].x=a[i][j];
ta1->td++;
}
ta1->md=n;
ta1->nd=m;
}
/*转置*/
void transition (tabletype *ta1, tabletype *tb1, List ta[],List tb[])
4.依次取A中的每一个非零元素对应的三元组;
2.1确定该元素在B中的下标pb;
2.2将该元素的行号列号交换后存入B中pb的位置;
2.3预置该元素所在列的下一个元素的存放位置;
具体要定义如下若干个函数:
void setup()初始化非零元的个数
void transition()转置函数
void input()输入函数
{ for(j=0;j<m;j++)
cout<<a[i][j]<<" ";
cout<<"\n";
}
}
/*三元组顺序表输出*/
void print2(List a[],int nn)
{
int i;
cout<<"\t行号\t列号\t元素值\n";
for(i=0; i<nn;i++)
cout<<" "<<a[i].p<<" "<<a[i].q<<" "<<a[i].x<<" "<<"\n";

稀疏矩阵课程设计实验报告

稀疏矩阵课程设计实验报告

数据结构课程设计学院:信息科学与工程学院专业:计算机科学与技术班级:计算机1108学号:学生姓名:指导教师:2013 年 3 月 10 日稀疏矩阵一、实验内容基本要求:1.以“带行逻辑链接信息”的三元组顺序表表示稀疏矩阵,实现两个矩阵相加、想减、相乘的运算。

2.稀疏矩阵的输入形式采用三元组表表示,而运算结果则以通常的阵列形式输出选作内容:1.按书中的描述方法,以十字链表表示稀疏矩阵2.增添矩阵求逆的运算,包括不可求逆的情况。

在求逆之前,先将稀疏矩阵的内容表示改为十字链表…二、数据结构设计三元组结构体定义如下:#include <stdio.h>#include <stdlib.h>#define MAX 100typedef struct{int i,j;int e;}Triple;struct juzhen{Triple data[MAX+1];int first[MAX+1];int mv,nv,tv;};十字链表结构定义如下#include<stdio.h>#include<stdlib.h>#include<conio.h>typedef int ElemType;typedef struct CLNode{int row ;int col;ElemType fenzi;ElemType fenmu;CLNode * right;CLNode * down;}CLNode;typedef struct{CLNode ** rhead;CLNode ** chead;int ru;int lu;int tu;}CrossList;三、算法设计1.三元组表构建稀疏矩阵的定义如下:ADT Matrix{数据对象:D={a ij|i=1,2,…,m; j=1,2,…,n;a ij∈ElemSet, m和n分别为矩阵的行数和列数}数据关系:R={Row,Col }Row={﹤a i,j, a i,j+1﹥| 1≤i≤m, 1≤j≤n-1}Col = {﹤a i,j, a i+1,j﹥| 1≤i≤m-1, 1≤j≤n}基本操作:ChuangJian (XiShu &M)操作结果:创建稀疏矩阵矩阵TMShuChu(XiShu Q)操作结果:通常形式输出稀疏矩阵AddMatrix(XiShu M,XiShu N,XiShu *Q)操作结果:稀疏矩阵的加法运算:void JianMatrix(XiShu M,XiShu N,XiShu *Q)操作结果:稀疏矩阵的减法运算void ChengMatrix(XiShu M,XiShu N,XiShu *Q)操作结果:稀疏矩阵的乘法运算}ADT Matrix;2 十字链表创建稀疏矩阵的定义如下:ADT SparseMatrix{数据对象 D={a ij|i=1,2,3……m,j=1,2,3……n;a ij属于ElemSet,m和n分别是稀疏矩阵的行数和列数}数据关系 R={ Row, Col }Row={<a ij,a ij+1>|1<=i<=m,1<=j<=n-1}Col={<a ij,a i+1j>|1<=i<=m-1,1<=j<=n}基本操作:void Input( CrossList &D )操作结果:十字链表创建稀疏矩阵int Determinant( const CrossList &D ,int row , int line )操作结果:求稀疏矩阵行列式的值void Reduction( int &fenzi, int &fenmu )操作结果:分子分母约分CrossList *InverseMatrix( const CrossList &D )操作结果:求稀疏矩阵的逆矩阵void Output( const CrossList *E )操作结果:十字邻接矩阵的输出}ADT SparseMatrix3.1 功能模块图本功能分为四个模块3.2 算法思路3.2.1实现方法列出系统中的所有函数并说明函数的功能void main() //三元组表法和十字链表的主函数int ChuangJian(XiShu *M) //三元组表法创建稀疏矩阵void ShuChu(XiShu Q) //三元组表法输出稀疏矩阵void AddMatrix(XiShu M,XiShu N,XiShu *Q)//三元组表法实现相加功能void JianMatrix(XiShu M,XiShu N,XiShu *Q)//三元组表法实现相减功能void ChengMatrix(XiShu M,XiShu N,XiShu *Q)//三元组表法实现相乘功能int Determinant(CrossList &D ,int row ,int line )//行列式求值void Reduction( int &fenzi, int &fenmu ) //分子分母约分void Input( CrossList &D ) //十字链表输入函数CrossList *InverseMatrix(CrossList &D)//求稀疏矩阵的逆矩阵void Output( const CrossList *E ) //十字链表输出函数3.2.2 设计思想稀疏矩阵加法运算思路:首先判断两个矩阵行数列数是否相等,比较两个矩阵中不为0的元素的行数i 及列数j,将i与j都相等的前后两个元素值e相加,保持i,j不变储存在新的三元组中,不等的则分别储存在此新三元组中稀疏矩阵减法运算思路:将后一个矩阵的每一个非零元都乘以-1,再调用加法运算的函数稀疏矩阵乘法运算思路:逐个定位两个矩阵的非零元的位置,从第一个矩阵的第一行开始,再从第二个矩阵的第一列开始,找到非零元相乘相加,并利用累加器逐列累加稀疏矩阵求逆运算的思路:矩阵的逆等于矩阵的伴随矩阵除以矩阵行列式的值(1)定义全局变量#define MAX 100#define TRUE 1#define FAULT 0typedef int ElemType;(2)主函数模块说明主函数主要结构void main( ){ 初始化;Switch(){Case :接受命令;选择处理命令}不满足退出}void main( ){初始化;接受命令;选择处理命令}(3)其他模块说明(用文字描述,不要代码)int CreateSMatrix(TSMatrix *M){初始化;输入行数、列数、非零元个数for(){for()按行为主序输入每一个非零元赋值}返回结果}void PrintSMatrix(TSMatrix Q){两层for循环输出每一个非零元}void AddRLSMatrix(TSMatrix M,TSMatrix N,TSMatrix *Q){判断行数、列数是否对应相等,若均相等则相加并赋值否则依次判断行数、列数的大小并再次判断将值放在另一个数组里}Void JianRLSMatrix(TSMatrix M,TSMatrix N,TSMatrix *Q){两层for循环将第二个矩阵的每一个非零元变为他的负数再调用相加函数}void MultSMatrix(TSMatrix M,TSMatrix N,TSMatrix *Q){初始化判断第一个矩阵的行数时候等于第二个矩阵的列数然后逐个定位两个矩阵的非零元的位置,从第一个矩阵的第一行开始,再从第二个矩阵的第一列开始,找到非零元相乘相加,并利用累加器逐列累加}四、测试数据及程序运行情况三元组表实现加法运算三元组表实现乘法运算十字链表实现求逆运算五、实验过程中出现的问题及解决方案1)问题:运行过程中发现加法减法能正常运行,而乘法却在计算时出现问题。

数据结构课程设计之稀疏矩阵实现与应用

数据结构课程设计之稀疏矩阵实现与应用

##大学数据结构课程设计报告题目:稀疏矩阵实现与应用院(系):计算机工程学院学生姓名:班级:学号:起迄日期: 2011.6.20-2011.6.29指导教师:2010—2011年度第 2 学期一、需求分析1.问题描述:要求:实现三元组,十字链表下的稀疏矩阵的加、转、乘的实现。

2.基本功能实现三元组,十字链表下的转置,乘法,加法运算。

3.输入输出(1)设计函数建立稀疏矩阵,初始化值。

(2)设计函数输出稀疏矩阵的值。

(3)构造函数进行两个稀疏矩阵相加,输出最终的稀疏矩阵。

(4)构造函数进行两个稀疏矩阵的相乘,输出最终的稀疏矩阵。

(5)构造函数进行稀疏矩阵的转置,并输出结果。

(6)退出系统。

二、概要设计1.设计思路:本实验要求在三元组,十字链表下实现稀疏矩阵的加、转、乘。

首先要进行矩阵的初始化操作,定义三元组和十字链表的元素对象。

写出转置,加法,乘法的操作函数。

通过主函数调用实现在一个程序下进行矩阵的运算操作。

2.数据结构设计:抽象数据类型稀疏矩阵的定义如下:ADT SparseMatrix{数据对象:D={aij | i=1,2,…,m; j=1,2,..,n;aij∈Elemset, m和n分别称为矩阵的行数和列数。

}数据关系:R={Row,Col}Row={<ai,j , ai,j+1> | 1<=i<=m, 1<=j<=n-1}Col= {<ai,j , ai+1,j> | 1<=i<=m-1, 1<=j<=n}基本操作:CreateSMatrix(&M);操作结果:创建稀疏矩阵M。

DestroySMatrix(&M);初始条件:稀疏矩阵M存在。

操作结果:销毁稀疏矩阵M。

PrintSMatrix(M);初始条件:稀疏矩阵M存在。

操作结果:输出稀疏矩阵M。

AddSMatrix(M,N,&Q);初始条件:稀疏矩阵M与N的行数和列数对应相等操作结果:求稀疏矩阵的和Q=M+N。

数据结构实验报告-特殊矩阵和稀疏矩阵

数据结构实验报告-特殊矩阵和稀疏矩阵

实验五特殊矩阵和稀疏矩阵【实验目的】1、掌握数组的结构类型(静态的内存空间配置);通过数组的引用下标转换成该数据在内存中的地址;2、掌握对称矩阵的压缩存储表示;3、掌握稀疏矩阵的压缩存储-三元组表表示,以及稀疏矩阵的转置算法。

【实验学时】2学时【实验预习】回答以下问题:1、什么是对称矩阵?写出对称矩阵压缩存储sa[k]与aij之间的对应关系。

2、什么是稀疏矩阵?稀疏矩阵的三元组表表示。

【实验内容和要求】1、编写程序exp5_1.c,将对称矩阵进行压缩存储。

(1)对称矩阵数组元素A[i][j]转换成为以行为主的一维数组sa[k],请描述k与ij的关系。

(注意C程序中,i,j,k均从0开始)(2)调试程序与运行。

对称矩阵存储下三角部分即i>=j。

对称矩阵为3,9,1,4,79,5,2,5,81,2,5,2,44,5,2,1,77,8,4,7,9参考程序如下:#include<stdio.h>#define N 5int main(){int upper[N][N]= {{3,9,1,4,7},{9,5,2,5,8},{1,2,5,2,4},{4,5,2,1,7},{7,8,4,7,9}}; /*对称矩阵*/int rowMajor[15]; /*存储转换数据后以行为主的数组*/int Index; /*数组的索引值*/int i,j;printf("Two dimensional upper triangular array:\n");for (i=0; i<N; i++) /*输出对称矩阵*/{for(j=0; j<N; j++)printf("%3d",upper[i][j]);printf("\n");}for(i=0; i<N; i++) /*进行压缩存储*/for(j=0; j<N; j++)if(____i>=j_____) /*下三角元素进行存储*/{Index=______i*(i+1)/2+j______; /*ij与index的转换*/rowMajor[Index]=upper[i][j];}printf("\nRow Major one dimensional array:\n");for(i=0; i<15; i++) /*输出转换后的一维数组*/printf("%3d", rowMajor[i]);printf("\n");return 1;}2、完成程序exp5_2.c,实现稀疏矩阵的三元组表存储及稀疏矩阵的转置。

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

数学与计算机学院课程设计说明书课程名称: 数据结构课程设计课程代码: 6014279题目: 稀疏矩阵的应用年级/专业/班: 2010级软件工程 2班学生姓名: 尹龙海学号: 312010*********开始时间: 2011 年 12 月 08 日完成时间: 2011 年 12 月 16 日课程设计成绩:指导教师签名:年月日数据结构课程设计任务书学院名称:数学与计算机学院课程代码:__ 8404181______ 专业:软件工程(Web方向)年级:2010级2班一、设计题目稀疏矩阵应用二、主要内容主要完成稀疏矩阵的加、转、乘的实现。

三、具体要求及应提交的材料以三元组、十字链表为存储形式,分别实现两个稀疏矩阵的加法运算、两个稀疏矩阵的乘法运算,以及对任意稀疏矩阵的转置运算。

稀疏矩阵要求可为键盘录入的任意矩阵。

用C/C++语言编程实现上述内容,对每个问题写出一个算法实现,并按数学与计算机学院对课程设计说明书规范化要求,写出课程设计说明书,并提交下列材料:1)课程设计说明书打印稿一份2)课程设计说明书电子稿一份;3)源程序电子文档一份。

四、主要技术路线提示注意合理地设计三元组及十字链表,结合稀疏矩阵的压缩存储方式和特点,将每一功能模块以函数形式分别实现。

在此基础上用C/C++实现其操作。

五、进度安排按教学计划规定,数据结构课程设计为2周,其进度及时间大致分配如下:六、推荐参考资料[1] 严蔚敏,吴伟民.数据结构.清华大学出版社出版。

[2] 严蔚敏,吴伟民. 数据结构题集(C语言版) .清华大学出版社.2003年5月。

[3] 唐策善,李龙澎.数据结构(作C语言描述) .高等教育出版社.2001年9月[4] 朱战立.数据结构(C++语言描述)(第二版本).高等出版社出版.2004年4月[5] 胡学钢.数据结构(C语言版) .高等教育出版社.2004年8月[6] 徐孝凯等著.数据结构(C语言描述).清华大学出版社.2004指导教师签名日期年月日系主任审核日期年月日目录摘要 (5)引言 (5)1 需求分析 (6)2 概要设计 (6)3详细设计 (8)4调试分析 (15)5用户使用说明 (15)6测试结果 (15)7结论 (19)致谢 (20)参考文献 (21)摘要本课程设计主要实现在三元组存储结构与十字链表存储结构下输入稀疏矩阵,并对稀疏矩阵进行转置,相加,相乘等操作,最后输出运算后的结果。

考虑到难易程度,先用三元组实现稀疏矩阵的输入,输出,及其转置,相加,相乘等操作的方法,再在十字链表下实现。

程序通过调试运行,结果与预期一样,初步实现了设计目标。

关键词:程序设计;稀疏矩阵;三元组;十字链表引言1.1课程设计任务本课程设计主要实现在三元组存储结构与十字链表存储结构下输入稀疏矩阵,并对稀疏矩阵进行转置,相加,相乘操作,最后输出运算后的结果。

稀疏矩阵采用三元组和十字链表表示,并在两种不同的存储结构下,求两个稀疏矩阵A 和B的和为矩阵C,并输出C;求出A的转置为矩阵D,输出D;求两个稀疏矩阵A和B的相乘为矩阵E,并输出E。

1.2课程设计性质数据结构课程设计是重要地实践性教学环节。

在进行了程序设计语言课和《数据结构》课程教学的基础上,设计实现相关的数据结构经典问题,有助于加深对数据结构课程的认识。

本课程设计是数据结构中的一个关于稀疏矩阵的算法的实现,包括在三元组和十字链表下存储稀疏矩阵,并对输入的稀疏矩阵进行转置,相加,相乘等操作,最后把运算结果输出。

此课程设计要求对数组存储结构和链表存储结构非常熟悉,并能熟练使用它们。

1.3课程设计目的其目的是让我们在学习完C++、数据结构等课程基础上,掌握多维数组的逻辑结构和存储结构、掌握稀疏矩阵的压缩存储及转置,相加,相乘等操作,并用不同的方法输出结果,进一步掌握设计、实现较大系统的完整过程,包括系统分析、编码设计、系统集成、以及调试分析,熟练掌握数据结构的选择、设计、实现以及操作方法,为进一步的应用开发打好基础。

需求分析2.1设计函数建立稀疏矩阵及初始化值和输出稀疏矩阵的值本模块要求设计函数建立稀疏矩阵并初始化,包括在三元组结构下和十字链表结构下。

在创建稀疏矩阵时,需要设计两个不同的函数分别在三元组和十字链表下创建稀疏矩阵,在输入出现错误时,能够对错误进行判别处理,初始化稀疏矩阵都为空值。

在设计输出稀疏矩阵的值的函数时,也要针对两种不同的情况,分别编制函数,才能准确的输出稀疏矩阵。

在对稀疏矩阵进行初始化时,只输入非零元素的值和它所在的所在行及所在列。

在对稀疏矩阵输出时,以矩阵的完整形式输出。

2.2构造函数进行稀疏矩阵的转置并输出结果本模块要求设计函数进行稀疏矩阵的转置并输出转置后的结果。

在编写函数时,要先定义一个相应的结构体变量用于存放转置后的矩阵,最后把此矩阵输出。

2.3构造函数进行两稀疏矩阵相加、减及相乘并输出最终稀疏矩阵本模块要求设计相加、减和相乘函数对两个矩阵进行运算,并输出最终的稀疏矩阵,定义相应的矩阵类型用于存放两个矩阵操作后的结果矩阵,这个结果矩阵的行、列数需要综合多方面情况来确定。

这些函数也是整个程序的难点,需要灵活运用数组及指针的特点。

2.4退出系统本模块要求设置选项能随时结束程序的运行,本程序中采用do-while循环。

程序在计算机上显示“提示信息”之后,由用户在键盘上输入演示程序中需要的相关信息及命令。

概要设计3.1存储结构设计三元组结构体定义:struct mat{int i;//非零元素的行位置int j;//非零元素的列位置int v;//非零元素的值};class sqmatrix{private:int m;//矩阵的行数int n;//矩阵的列数int t;//矩阵中非零元素的个数mat data[max];//三元组表int rpos[max];//存储矩阵中第max行以前所有非零元素的个数public:};十字链表结构体定义:typedef struct OLNode{int i,j; //该非零元的行、列下标int e; //非零元值struct OLNode *right,*down; // 该非零元所在行表和列表的后继元素}OLNode,*OLink;// 定义十字链表对象结构体typedef struct{OLink *rhead,*chead; //OLink类型结点数组int a,b,c; // 系数矩阵的行数,列数,和非零元素个数}CrossList;3.2系统功能设计本系统除了要完成分别在三元组存储结构以及在十字链表下实现稀疏矩阵的初始化功能外还设置了4个子功能菜单。

稀疏矩阵的建立及初始化在三元组存储结构下,由函数void creat()实现,在十字链表存储结构下,由函数void CreateSMatix_OL(CrossList &M)依据读入的行数和列数以及非零元素的个数,分别设定每个非零元素的信息。

4个子功能的设计描述如下。

(1)稀疏矩阵的转置:此功能在三元组存储结构下,有两种方法:按行转置和按列转置,分别由函数sqmatrix transmatone()和sqmatrix transmattwo()实现,在十字链表存储结构下,由函数void zhuanzhi( )实现。

当用户选择该功能,系统提示用户初始化一个矩阵,然后进行转置,最终输出结果。

(2)稀疏矩阵的加法:此功能在三元组存储结构下,由函数void add(sqmatrix a,sqmatrix b)实现,在十字链表存储结构下,由函数void add()实现。

当用户选择该功能,系统即提示用户初始化要进行加法的两个矩阵的信息。

然后进行加法,最后输出结果。

(3)稀疏矩阵的乘法:此功能在三元组存储结构下,由函数void cheng(sqmatrix a,sqmatrix b)实现。

在十字链表存储结构下,由函数void chengfa()实现。

当用户选择该功能,系统提示输入要进行相乘的两个矩阵的详细信息。

然后进行相乘,最后得到结果。

(4)退出:即退出稀疏矩阵的应用系统,由switch语句实现。

当用户选择相应序号,则退出该稀疏矩阵的应用系统。

详细设计4.1 数据类型定义三元组结构体定义:struct mat{int i;//非零元素的行位置int j;//非零元素的列位置int v;//非零元素的值};class sqmatrix{private:int m;//矩阵的行数int n;//矩阵的列数int t;//矩阵中非零元素的个数mat data[max];//三元组表int rpos[max];//存储矩阵中第max行以前所有非零元素的个数public:};十字链表结构体定义:typedef struct OLNode{int i,j; //该非零元的行、列下标int e; //非零元值struct OLNode *right,*down;}OLNode,*OLink;typedef struct{OLink *rhead,*chead; //OLink类型结点数组int a,b,c; // 系数矩阵的行数,列数,和非零元素个数}CrossList;4.2系统主要子程序详细设计A. 主程序模块设计:采用一个do-while语句执行各个功能的操作循环,并用switch语句控制选择三元组或十字链表进行相关的操作,在采用的操作界面中,再用switch 语句控制各功能的实现,主要代码如下:do{cout<<endl;cout<<"\n ***稀疏矩阵应用***"<<endl<<endl;cout<<"\n 请你选择创建稀疏矩阵的方法"<<endl;cout<<"\n 1、用三元组创建稀疏矩阵"<<endl;cout<<"\n 2、用十字链表创建稀疏矩阵"<<endl;cout<<"\n 3、退出程序"<<endl<<endl;cout<<"请选择:";cin>>k; cout<<endl;switch(k){case 1: {cout<<" 欢迎进入《三元组操作》矩阵系统"<<endl<<endl;switch(kk){case 1: 两矩阵求和}break;case 2: {两矩阵相乘}break;case 3: {矩阵按行转置}break;case 4: {矩阵按行转置}break;case 5: {退出该程序}break;}cout<<endl; }break;case 2: {cout<<" 欢迎进入《十字链表操作》矩阵系统"<<endl<<endl;switch(kk) {case 1: {两矩阵求和}break;case 2: {两矩阵相乘}break;case 3: {两矩阵相减}break;case 4: {矩阵转置}break;case 5: {退出该程序}break;}cout<<endl; }break; }}while(k==1||k==2); cout<<endl; return 0; }B. 稀疏矩阵操作各子函数的定义:(1)建立与初始化稀疏矩阵:采用三元组建立稀疏矩阵,输入非零元素的行号、列号和值,关键代码如下:cout<<"行号i 列号j 非零元素值v"<<endl;for(int p=0;p<t;p++){cout<<" ";cin>>ii;data[p].i=ii;cout<<" ";cin>>jj;data[p].j=jj;cout<<" ";cin>>element;data[p].v=element; cout<<endl; }采用十字链表建立稀疏矩阵,输入非零元素的行号、列号和值,给新结点申请空间,按列循环链表和行循环链表形式插入到十字链表中关键代码如下:{int x,y,m; cout<<"请输入稀疏矩阵的行,列,及非零元素个数"<<endl;cin>>M.a>>M.b>>M.c;cout<<"请按三元组的格式输入数组:"<<endl;for(int i=1;i<=M.c;i++){ cin>>x>>y>>m; cout<<endl; OLink p,q;p->i=x; p->j=y; p->e=m;if(M.rhead[x]==NULL||M.rhead[x]->j>y) {p->right=M.rhead[x]; M.rhead[x]=p; }else{ for(q=M.rhead[x];(q->right)&&(q->right->j<y);q=q->right);p->right=q->right; q->right=p; }if(M.chead[y]==NULL||M.chead[y]->i>x){p->down=M.chead[y]; M.chead[y]=p; }else{for(q=M.chead[y];(q->down)&&(q->down->i<x);q=q->down); p->down=q->down; q->down=p; } } (2)输出稀疏矩阵:用三元组输出矩阵元素时,若稀疏矩阵所对应的元素在三元组中有该元素,则输出三元组中的这个元素的值,否则,输出零。

相关文档
最新文档