采用十字链表表示稀疏矩阵,并实现矩阵的加法运算

合集下载

课程设计模板

巢湖学院信息工程学院

课程设计报告

课程名称《数据结构》

课题名称稀疏矩阵的实现与应用专业网络工程

班级16网工二班

学号

姓名

联系方式

指导教师刘波

20 16 年 6 月 13 日

1、数据结构课程设计任务书.............................................................................................. １

1.1、题目..................................................................................................................... １

1.2、要求..................................................................................................................... １

2、总体设计....................................................................................................................... １

2.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-1

十字链表的存储与运算

⼗字链表的存储与运算

#include

typedef int ElemType;// 稀疏矩阵的⼗字链表存储表⽰

typedef struct OLNode

{

int i,j; // 该⾮零元的⾏和列下标

ElemType e; // ⾮零元素值

struct OLNode *right,*down; // 该⾮零元所在⾏表和列表的后继链域}OLNode, *OLink;

typedef struct// ⾏和列链表头指针向量基址,由CreatSMatrix_OL()分配{

OLink *rhead, *chead;

int mu, nu, tu; // 稀疏矩阵的⾏数、列数和⾮零元个数

}CrossList;

// 初始化M(CrossList类型的变量必须初始化,否则创建、复制矩阵将出错) int InitSMatrix(CrossList *M) {

(*M).rhead=(*M).chead=NULL;

(*M).mu=(*M).nu=(*M).tu=0;

return 1;

}

// 销毁稀疏矩阵M

int DestroySMatrix(CrossList *M)

{

int i;

OLNode *p,*q;

for(i=1;i<=(*M).mu;i++) // 按⾏释放结点

{

p=*((*M).rhead+i);

while(p)

{

q=p;

p=p->right;

free(q);

}

free((*M).chead);

(*M).rhead=(*M).chead=NULL;

(*M).mu=(*M).nu=(*M).tu=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

数据结构课程设计稀疏矩阵

稀疏矩阵应用

摘要本课程设计主要实现在三元组存储结构与十字链表存储结构下输入稀疏矩阵，并对稀疏矩阵进行转置，相加，相乘操作，最后输出运算后的结果。在程序设计中，考虑到方法的难易程度，采用了先用三元组实现稀疏矩阵的输入，输出，及其转置，相加，相乘操作的方法，再在十字链表下实现。程序通过调试运行，结果与预期一样，初步实现了设计目标。

关键词程序设计；稀疏矩阵；三元组；十字链表

1 引言

1.1课程设计任务

本课程设计主要实现在三元组存储结构与十字链表存储结构下输入稀疏矩阵，并对稀疏矩阵进行转置，相加，相乘操作，最后输出运算后的结果。稀疏矩阵采用三元组和十字链表表示，并在两种不同的存储结构下，求两个具有相同行列数的稀疏矩阵A和B的相加矩阵C，并输出C；求出A的转置矩阵D，输出D；求两个稀疏矩阵A和B的相乘矩阵E，并输出E。

1.2课程设计性质

数据结构课程设计是重要地实践性教学环节。在进行了程序设计语言课和《数据结构》课程教学的基础上，设计实现相关的数据结构经典问题，有助于加深对数据结构课程的认识。本课程设计是数据结构中的一个关于稀疏矩阵的算法的实现，包括在三元组和十字链表下存储稀疏矩阵，并对输入的稀疏矩阵进行转置，相加，相乘等操作，最后把运算结果输出。此课程设计要求对数组存储结构和链表存储结构非常熟悉，并能熟练使用它们。

1.3课程设计目的

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

稀疏矩阵的乘法运算(十字链表)

if(M.nu!=N.mu) exit(Overflow); Q.mu=M.mu; Q.nu=N.nu; Q.tu=0; OLnode *p,*q,*t; Olink temp;
int e,col; Q.rhead=(Olink *)malloc((Q.mu+1)*sizeof(Olink)); Q.chead=(Olink *)malloc((Q.nu+1)*sizeof(Olink)); if(!Q.rhead) exit(Overflow); if(!Q.chead) exit(Overflow);
} else
cout<<0<<" "; } cout<<endl; } }
void main() {
Crosslist M,N,Q; input(M); input(N); cout<<"矩阵M:"<<endl; output(M); cout<<"矩阵N:"<<endl; output(N); chengfa(M,N,Q); cout<<"矩阵M、N的乘积为："<<endl; output(Q);
} } } void output(Crosslist M) //输出矩阵M { OLnode *pp; for(int i=1;i<=M.mu;i++) { pp=M.rhead[i]; for(int j=1;j<=M.nu;j++) {

十字链表实现稀疏矩阵的加法

按要求再依次实入222315实矩实a实入完成程序按矩实格式实出矩实a程序实实提示实实入行列数非零元数个数在按上述操作实实实入334112211311333实矩实b实入完成后程序实入矩实b程序同实实出ab3实果分析程序提供实入和实出根据实入的矩实a和矩实bab实算实果准无实
实验二十Βιβλιοθήκη Baidu链表
一、实验题目
以十字链表为储存结构，实现稀疏矩阵的求和运算。
p->down=pre->down;
pre->down=p;
}
5、在p->col列中删除结点p，并释放空间
template<class Type>void LinkMatrix<Type>::DeleteInCol(MatrixNode<Type>*p)
{
MatrixNode<Type>*pre,*ch=Head(p->col);
3、其他函数
1）主函数main（）
2）作为友元函数的加法运算。
4、详细设计
用十字链表表示稀疏矩阵，需要定义结点类和链表类两个类
1、结点类MatrixNode
template<class Type>class MatrixNode
{
friend class LinkMatrix<Type>;

十字链表存储稀疏矩阵算法

十字链表存储稀疏矩阵实现相乘算法

#include <stdio.h>

#include <stdlib.h>

#include <assert.h>

#define OK 1

#define ERROR 0

typedef struct list

{

int row;

int colum;

int value;

struct list *right;

struct list *down;

}node,*element;

typedef struct link

{

int row_size;

int colum_size;

int non_zero_amount;

element *rhead;

element *chead;

}crosslist;

int init_matrix(crosslist &one)

{

one.row_size=0;

one.colum_size=0;

one.non_zero_amount=0;

one.rhead=NULL;

one.chead=NULL;

return OK;

}

int creat_matrix(crosslist &one)

{

int i;

element news,temp;

printf("Input the row size of the matrix:");

scanf("%d",&one.row_size);

printf("Input the colum size of the matrix:"); scanf("%d",&one.colum_size);

稀疏矩阵十字链表算法

稀疏矩阵是指矩阵中绝大多数元素为0的矩阵。在实际应用中，很多矩阵都具有稀疏性，即元素中大部分为0，而只有少数非零元素。对于这种类型的矩阵，为了节省内存空间并提高计算效率，可以采用稀疏矩阵的存储方式。

稀疏矩阵的一种常用存储方式是十字链表。十字链表是一种将稀疏矩阵以链表形式存储的数据结构，它能够有效地表示稀疏矩阵的非零元素，并且能够方便地进行插入、删除和查找操作。

稀疏矩阵十字链表的基本思想是将矩阵中的每个非零元素存储为一个结点，并将这些结点以行列坐标的方式进行链接。具体来说，稀疏矩阵十字链表由两个链表组成：行链表和列链表。

行链表是一个以行为主的链表，每个结点表示矩阵中的一行。每个结点包含三个字段：行号、列号和值。行链表中的结点按照行号从小到大的顺序进行排列，同一行中的结点按照列号从小到大的顺序进行排列。

列链表是一个以列为主的链表，每个结点表示矩阵中的一列。每个结点也包含三个字段：行号、列号和值。列链表中的结点按照列号从小到大的顺序进行排列，同一列中的结点按照行号从小到大的顺序进行排列。

通过行链表和列链表，可以方便地进行插入、删除和查找操作。插入操作可以通过在行链表和列链表中找到对应的位置，将新结点插入到相应的位置上。删除操作可以通过在行链表和列链表中找到对应的位置，将对应的结点删除。查找操作可以通过在行链表和列链表中找到对应的位置，获取对应的结点。

稀疏矩阵十字链表算法的优点是能够有效地存储稀疏矩阵，并且可以方便地进行插入、删除和查找操作。相比于其他存储方式，稀疏矩阵十字链表可以节省更多的内存空间，并且具有更高的计算效率。

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

一．需求分析

输入要求：稀疏矩阵的行、列和非零元素个数

输出要求：稀疏矩阵的转置、加法、减法、乘法

二．算法设计

本程序中采用的数据模型，用到的抽象数据类型的定义，程序的主要算法流程及各模块之间的层次调用关系

1．抽象数据类型：

ADT List {

数据对象：D={ai:|ai∈ElemSet,i=1…n,n≥0}

数据关系：R={Row,Col}

Row={|1<=i<=m,1<=j<=n-1}

Col={|1<=i<=m-1,1<=j<=n}

基本操作:

Status CreateSMatrix(TSMatrix &M)

操作结果：初始化稀疏数组

void PrintSMatrix(TSMatrix M)

初始条件：稀疏数组M已经存在

操作结果：打印矩阵M

void DestroySMatrix(TSMatrix &M)

初始条件：稀疏数组M已经存在

操作结果：销毁矩阵M

void CopySMatrix(TSMatrix M, TSMatrix &T)

初始条件：稀疏数组M已经存在

操作结果：复制矩阵M到T

Status AddSMatrix(TSMatrix M, TSMatrix N, TSMatrix &Q)

初始条件：稀疏数组M、N已经存在

操作结果：求矩阵的和Q=M+N

Status SubSMatrix(TSMatrix M, TSMatrix N, TSMatrix &Q)

初始条件：稀疏数组M、N已经存在

操作结果：求矩阵的差Q=M-N

Status TransposeSMatrix(TSMatrix M, TSMatrix & T)

稀疏矩阵的十字链表

稀疏矩阵是指在大多数元素都为零的情况下，只有少部分元素非零的矩阵。与之相对应的是稠密矩阵，即大多数元素都非零的矩阵。为了节省存储空间，我们可以采用特殊的数据结构来存储稀疏矩阵。其中，十字链表是一种常用的数据结构。

十字链表是一种链式存储结构，用于存储稀疏矩阵。它的基本思想是先将矩阵按行分解成一组行链表，再将矩阵按列分解成一组列链表。每个非零元素在行链表和列链表中各有一个结点，这个结点包括该元素在矩阵中的行、列编号以及该元素的值。通过行链表和列链表，我们可以快速地访问矩阵中的非零元素。

具体来说，十字链表包括两种结点，分别为行结点和列结点。行结点的数据成员包括该非零元素所在的行号、列号、该元素的值，以及指向同一行中下一个非零元素的指针和同一列中下一个非零元素的指针。列结点的数据成员包括该非零元素所在的行号、列号、该元素的值，以及指向同一列中下一个非零元素的指针和同一行中下一个非零元素的指针。通过这样的链式存储结构，我们可以实现在O(k)的时间复杂度内访问矩阵中任意一个非零元素，其中k为矩阵中非零元素的个数。

总的来说，十字链表是一种用于存储稀疏矩阵的高效数据结构，它采用链式存储方式，能够快速地访问矩阵中的非零元素，并且能够有效地节省存储空间。

稀疏矩阵十字链表算法

稀疏矩阵是指矩阵中大部分元素为0的矩阵。在实际应用中，稀疏矩阵常常出现，比如图像处理、网络分析等领域。由于稀疏矩阵中存在大量的0元素，传统的二维数组存储方式会造成内存空间的浪费，因此需要一种高效的数据结构来表示和存储稀疏矩阵。稀疏矩阵十字链表算法就是一种解决这个问题的方法。

稀疏矩阵十字链表算法是一种基于链表的数据结构，用于表示和存储稀疏矩阵。它通过两个链表来分别表示行和列，同时还使用了一个数据链表来存储非零元素的值和位置信息。这种算法的核心思想是将稀疏矩阵的非零元素存储在链表中，并记录它们在矩阵中的位置信息，从而节省了存储空间。

具体来说，稀疏矩阵十字链表算法中，我们可以使用三个结构体来表示矩阵的行、列和非零元素。其中，行和列的结构体包含了指向非零元素的指针和矩阵的维度信息。非零元素的结构体包含了元素的值、行列坐标以及指向下一个非零元素的指针。

使用稀疏矩阵十字链表算法存储稀疏矩阵的好处是，它不仅节省了存储空间，还可以提高对稀疏矩阵的操作效率。比如，对于稀疏矩阵的遍历操作，我们可以通过遍历链表的方式来实现，而不需要遍历整个矩阵，从而减少了时间复杂度。

除了存储和遍历操作，稀疏矩阵十字链表算法还可以支持其他一些常见的矩阵操作，比如矩阵的相加、相乘等。对于这些操作，我们只需要按照链表的顺序进行遍历，并根据矩阵的位置信息进行计算即可。

稀疏矩阵十字链表算法的实现过程相对简单，但需要注意一些细节。首先，我们需要确定稀疏矩阵的维度信息，并创建相应的行和列的链表头结点。然后，我们可以按照行优先的方式遍历整个矩阵，将非零元素插入到链表中，并更新行和列的指针。最后，我们可以根据需要进行各种矩阵操作。

稀疏矩阵的十字链表存储的思路

稀疏矩阵是指大部分元素都是零的矩阵。为了避免浪费存储空间，可以采用十字链表存储法。

具体实现思路如下：

1. 定义结构体Node，表示矩阵中的一个非零元素。

2. 定义结构体CrossListNode，表示十字链表中的一个节点，

包含4个指针，分别指向同一行中的下一个非零元素、同一列中的下一个非零元素、上一个非零元素以及左一个非零元素。

3. 定义结构体CrossListMatrix，表示十字链表矩阵，包含三

个变量：矩阵的行数、列数和非零元素数目，以及两个指针，分别指向行和列的头节点。

4. 创建行和列的头节点，依次扫描矩阵中的非零元素，创建一

个Node节点，并把它插入到行和列的链表中。同时，记录该元素在

行和列中的位置，以便于更新节点的指针。

5. 最后建立行和列之间的链接，即将同一行中的节点按照列的

顺序链接起来，同理，将同一列中的节点按照行的顺序链接起来。

6. 完成十字链表矩阵的存储。

通过以上方法，可以有效地减少存储空间的浪费，提高矩阵的存储效率，同时也方便了对矩阵中非零元素的操作。

- 1 -

数据结构课程设计参考题目

数据结构课程设计题目

数据结构课程设计题目(大题目).doc

一、公司销售管理系统

项目开发基本要求

1．客户信息管理：对客户的基本信息进行添加、修改和删除。

2．产品信息管理：对产品的基本信息进行添加、修改和删除。

3．供应商信息管理：对供应商的基本信息进行添加、修改和删除。

4．订单信息管理：对订单的基本信息进行添加、修改和删除。

二、高校科研管理系统

系统主要用于帮助高校或科研单位管理和维护各项科研相关资料

项目开发基本要求

1．系统用户管理模块：为系统新用户设置用户名及口令；操作员更改自己的系统口令。2．数据字典管理模块：管理项目性质包括：分为国家自然科学基金、863、部省科委及企业集团四种情况；范围包括：分为全国、国际、地方三种情况；检索源包括：分为EI、SC I、核心和一般四种情况。

3．项目参加人员管理模块包括：显示添加修改删除查询。

4．项目基本情况模块包括：显示添加修改删除查询。

5．项目获奖情况模块包括：显示添加修改删除查询。

6．期刊论文管理模块包括：显示添加修改删除查询。

7．著作管理模块包括：显示添加修改删除查询。

8．科研工作量统计模块：按照学校科研工作量计算办法，为每位科研人员进行科研工作量的计算和统计。

9．科研积分统计模块：按照学校科研积分计算办法，为每位科研人员进行科研计分的计算和统计。

三、网络五子棋对战

四、不同排序算法模拟

五、科学计算器

数据结构课程设计题目

1.运动会分数统计

任务：参加运动会有n个学校，学校编号为1……n。比赛分成m 个男子项目，和w个女子项目。项目编号为男子1……m，女子m+1……m+w。不同的项目取前五名或前三名积分；取前五名的积分分别为：7、5、3、2、1，前三名的积分分别为：5、3、2；哪些取前五名或前三名由学生自己设定。（m<=20,n<=2 0）

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

数据结构课程设计

学院：信息科学与工程学院

专业：计算机科学与技术

班级：计算机1108

学号：

学生姓名：

指导教师：

2013 年 3 月 10 日

稀疏矩阵

一、实验内容

基本要求：

1.以“带行逻辑链接信息”的三元组顺序表表示稀疏矩阵，实现两个矩阵相加、

想减、相乘的运算。

2.稀疏矩阵的输入形式采用三元组表表示，而运算结果则以通常的阵列形式输出

选作内容：

1.按书中的描述方法，以十字链表表示稀疏矩阵

2.增添矩阵求逆的运算，包括不可求逆的情况。在求逆之前，先将稀疏矩阵的内

容表示改为十字链表

…

二、数据结构设计

三元组结构体定义如下：

#include <stdio.h>

#include <stdlib.h>

#define MAX 100

typedef 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;

采用十字链表存储的稀疏矩阵

采⽤⼗字链表存储的稀疏矩阵

Description

当矩阵的⾮零元个数和位置在操作过程中变化较⼤时，就不宜采⽤顺序存储的结构来表⽰三元组的线性表了。因此，在这种情况下，采⽤链式存储结构表⽰三元组更为恰当。⼗字链表就是能够实现这样功能的⼀种数据结构。

在⼗字链表中，每个⾮零元可以⽤⼀个包含5个域的结点表⽰。其中i、j和e这3个域分别表⽰该⾮零元所在的⾏、列和⾮零元的值，向右域right⽤来链接同⼀⾏中下⼀个⾮零元，⽽向下域down⽤来链接同⼀列中下⼀个⾮零元。同⼀⾏的⾮零元通过right域链接成⼀个线性链表，同⼀列的⾮零元通过down域链接成⼀个线性链表。每个⾮零元既是某个⾏链表中的⼀个结点，⼜是某个列链表中的⼀个结点，整个矩阵通过这样的结构形成了⼀个⼗字交叉的链表。

稀疏矩阵的⼗字链表类型可以描述如下：

下⾯是建⽴稀疏矩阵⼗字链表的算法描述：

给出⼀个稀疏矩阵，请将其存储到⼀个⼗字链表中，并将存储完毕的矩阵输出。

Input

输⼊的第⼀⾏是两个整数r和c（r<200, c<200, r*c <= 12500），分别表⽰⼀个包含很多0的稀疏矩阵的⾏数和列数。接下来有r⾏，每⾏有c个整数，⽤空格隔开，表⽰稀疏矩阵的各个元素。

Output

输出读⼊的矩阵。输出共有r⾏，每⾏有c个整数，每个整数后输出⼀个空格。请注意⾏尾输出换⾏。

Sample Input

5 6

0 18 0 0 0 0

0 0 67 0 0 0

0 0 0 0 0 41

0 0 47 62 0 0

0 0 0 0 0 35

Sample Output