数据结构C语言版-稀疏矩阵三元组的基本操作
数据结构之稀疏矩阵稀疏矩阵的存储方式和操作分析
数据结构之稀疏矩阵稀疏矩阵的存储方式和操作分析稀疏矩阵是指矩阵中大部分元素为零的特殊矩阵。
在实际应用中，稀疏矩阵经常出现，如图像处理、网络分析和科学计算等领域。
对于稀疏矩阵的存储和操作是数据结构中的重要内容。
本文将介绍稀疏矩阵的存储方式和相关操作的分析。
一、稀疏矩阵存储方式稀疏矩阵的存储方式有多种，其中三元组顺序表和二维数组是比较常用的方法。
1. 三元组顺序表三元组顺序表是一种基于行优先存储的方式，可以将稀疏矩阵以非零元素的形式存储起来。
主要包括行号、列号和元素值三个信息。
以一个4x5的稀疏矩阵为例，其中有三个非零元素分别为A[1][2]=3, A[2][3]=4, A[3][4]=5。
可以使用三元组顺序表来存储：```行号列号元素值1 2 32 3 43 4 5```三元组顺序表的优点是可以节省存储空间，同时也方便进行矩阵的操作。
但是在进行元素的查找和修改时，效率较低。
2. 二维数组二维数组是一种常见的矩阵表示方法，可以直接使用二维数组来表示稀疏矩阵。
其中非零元素的位置用实际的值表示，其余位置用零值表示。
以同样的4x5的稀疏矩阵为例，使用二维数组存储如下：```0 0 0 0 00 0 3 0 00 0 0 4 00 0 0 0 5```二维数组的优点是简单直观，并且可以快速进行元素的查找和修改。
但当稀疏矩阵的规模较大时，会造成较高的存储资源浪费。
二、稀疏矩阵的操作分析对于稀疏矩阵的操作，主要包括矩阵的转置、相加、相乘等。
1. 转置操作稀疏矩阵的转置是指将原始矩阵的行与列对调。
对于三元组顺序表来说，转置操作主要涉及到行号和列号的交换。
而对于二维数组来说，可以直接在取值的时候将行号和列号对调即可。
2. 相加操作稀疏矩阵的相加操作是指将两个矩阵对应位置的元素相加。
对于三元组顺序表来说，可以通过遍历两个矩阵的非零元素，并将其对应位置的元素相加。
而对于二维数组来说，可以直接将对应位置的元素相加即可。
3. 相乘操作稀疏矩阵的相乘操作是指将两个矩阵相乘得到一个新的矩阵。
实验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; }二、运行结果：三、算法分析：。
稀疏矩阵的三元组顺序表示方法C++代码
#include<stdio.h>#include<stdlib.h>#define OK 1#define ERROR 0#define INFEASIBLE -1#define OVERFLOW -2#define MAXSIZE 100typedef int Status;typedef int ElemType;typedef struct{int i,j;ElemType e;}Triple;typedef struct{int mu,nu,tu;Triple data[MAXSIZE+1];}TSMatrix;Status CreatSMatrix(TSMatrix &M)//创建新的稀疏矩阵{printf("输入稀疏方阵的行数,列数以及非零元个数：");scanf("%d%d%d",&M.mu,&M.nu,&M.tu);while(M.tu>M.mu * M.nu){printf("输入稀疏方阵的行数,列数以及非零元个数：");scanf("%d%d%d",&M.mu,&M.nu,&M.tu);}int k;for( k=1;k<=M.tu;k++){printf("输入第%d个非0元素的行数,列数以及值:",k);scanf("%d%d%d",&M.data[k].i,&M.data[k].j,&M.data[k].e);if(M.data[k].i>M.mu || M.data[k].j>M.nu )printf("输入错误!\n");system("PAUSE");exit(1);}while(M.data[k].e==0){printf("输入的必须是非零元素!\n");scanf("%d,%d,%d",&M.data[k].i,&M.data[k].j,&M.data[k].e);}}return OK;}Status PrintSMatrix(TSMatrix &X){if(!X.tu){printf("矩阵为空!\n");return 0;}int i,j,k=1;for(i=1;i<=X.mu;i++){ for(j=1;j<=X.nu;j++){ if(i==X.data[k].i && j==X.data[k].j){printf("%2d ",X.data[k].e);k++;} else printf(" 0 ");}printf("\n");}return OK;}Status TransposeSMatrix(TSMatrix M,TSMatrix &T){T.mu = M.nu;T.nu = M.mu;T.tu = M.tu;if(T.tu){int col;int p;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;}}return OK;}void main(){TSMatrix M;TSMatrix T;int choice;do{printf("\n请输入你的选择：\n");printf("1 创建稀疏矩阵\n");printf("2 该矩阵的转值\n");printf("0 退出\n");scanf("%d",&choice);switch(choice){case 1:printf("\n");CreatSMatrix(M);printf("\n");PrintSMatrix(M);break;case 2:printf("\n");TransposeSMatrix( M,T);printf("\n");PrintSMatrix(T);break;default:printf("\n\n你输入的信号无效!\n\n");break;}}while(choice!=0);}。
三元组实现稀疏矩阵加减乘
#include<stdio.h>#include<stdlib.h>#define MAXSIZE 12500//三元组结构typedef struct {int i,j; //矩阵行下标和列下标int e; //值}Triple;//矩阵结构typedef struct{Triple data[MAXSIZE+1];int rpos[MAXSIZE+1]; //这是存放各行第一非零元在矩阵中的位置int mu,nu,tu; //矩阵的行数、列数、非零元个数}Matrix;void Init(Matrix* M);void Add(Matrix* M,Matrix* T,Matrix* G);void Jian(Matrix* M,Matrix* T,Matrix* G);void Cheng(Matrix* M,Matrix* T,Matrix* G);void Cheng(Matrix* M,Matrix* T,Matrix* G);void PrintMatrix(Matrix* M);//2、初始化矩阵void Init(Matrix* M){int i;if(M->mu < 1 || M->nu < 1 || M->tu > M->mu*M->nu){printf("出错!\n"); //如果矩阵的行数、列数不符合要求，打印出错}for(i=1;i<=M->tu;i++) //data[0]不用{printf("第%d个非零元的行号：",i); //以下为数据初始化scanf("%d",&M->data[i].i);printf("第%d个非零元的列号：",i);scanf("%d",&M->data[i].j);printf("第%d个非零元的元素值：",i);scanf("%d",&M->data[i].e);}printf("\n");printf("您创建的矩阵如下:\n");PrintMatrix(M);}//3、矩阵相加void Add(Matrix* M,Matrix* T,Matrix* G){G->mu = M->mu; //因为加减运算必须维数相等，所以M、T行、列数相等，初始化第三方矩阵的行、列数。
稀疏矩阵编程实验报告
一、实验目的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. 通过编程实现稀疏矩阵的基本操作，验证了算法的正确性。
数据结构C语言版稀疏矩阵的三元组顺序表存储表示和实现
typedef int ElemType;// 稀疏矩阵的三元组顺序表存储表示define MAXSIZE 100 // 非零元个数的最大值typedef struct{int i;j; // 行下标;列下标ElemType e; // 非零元素值}Triple;typedef struct{Triple dataMAXSIZE+1; // 非零元三元组表;data0未用int mu;nu;tu; // 矩阵的行数、列数和非零元个数}TSMatrix;// 创建稀疏矩阵Mint CreateSMatrixTSMatrix M{int i;m;n;ElemType e;int k;printf"请输入矩阵的行数;列数;非零元素个数：逗号\n";scanf"%d;%d;%d";&M.mu;&M.nu;&M.tu;M.data0.i=0; // 为以下比较顺序做准备fori = 1; i <= M.tu; i++{do{printf"请按行序顺序输入第%d个非零元素所在的行1～%d;""列1～%d;元素值：逗号\n"; i;M.mu;M.nu;scanf"%d;%d;%d";&m;&n;&e;k=0;// 行或列超出范围ifm < 1 || m > M.mu || n < 1 || n > M.nuk=1;ifm < M.datai-1.i || m == M.datai-1.i&& n <= M.datai-1.j // 行或列的顺序有错k=1;}whilek;M.datai.i = m; //行下标M.datai.j = n; //列下标M.datai.e = e; //该下标所对应的值}return 1;}// 销毁稀疏矩阵M;所有元素置空void DestroySMatrixTSMatrix M{M.mu=0;M.nu=0;M.tu=0;}// 输出稀疏矩阵Mvoid PrintSMatrixTSMatrix M{int i;printf"\n%d行%d列%d个非零元素..\n";M.mu;M.nu;M.tu;printf"%4s%4s%8s\n"; "行"; "列"; "元素值";fori=1;i<=M.tu;i++printf"%4d%4d%8d\n";M.datai.i;M.datai.j;M.datai.e; }// 由稀疏矩阵M复制得到Tint CopySMatrixTSMatrix M;TSMatrix T{T=M;return 1;}// AddSMatrix函数要用到int compint c1;int c2{int i;ifc1<c2i=1;else ifc1==c2i=0;elsei=-1;return i;}// 求稀疏矩阵的和Q=M+Nint AddSMatrixTSMatrix M;TSMatrix N;TSMatrix Q{Triple Mp;Me;Np;Ne;Qh;Qe;ifM.mu=N.mureturn 0;ifM.nu=N.nureturn 0;Q.mu=M.mu;Q.nu=M.nu;Mp=&M.data1; // Mp的初值指向矩阵M的非零元素首地址Np=&N.data1; // Np的初值指向矩阵N的非零元素首地址Me=&M.dataM.tu; // Me指向矩阵M的非零元素尾地址Ne=&N.dataN.tu; // Ne指向矩阵N的非零元素尾地址Qh=Qe=Q.data; // Qh、Qe的初值指向矩阵Q的非零元素首地址的前一地址whileMp <= Me && Np <= Ne{Qe++;switchcompMp->i;Np->i{case 1:Qe=Mp;Mp++;break;case 0:// M、N矩阵当前非零元素的行相等;继续比较列switchcompMp->j;Np->j{case 1:Qe=Mp;Mp++;break;case 0:Qe=Mp;Qe->e+=Np->e;ifQe->e // 元素值为0;不存入压缩矩阵Qe--;Mp++;Np++;break;case -1:Qe=Np;Np++;}break;case -1:Qe=Np;Np++;}}ifMp>Me // 矩阵M的元素全部处理完毕whileNp<=Ne{Qe++;Qe=Np;Np++;}ifNp>Ne // 矩阵N的元素全部处理完毕whileMp<=Me{Qe++;Qe=Mp;Mp++;}Q.tu=Qe-Qh; // 矩阵Q的非零元素个数return 1;}// 求稀疏矩阵的差Q=M-Nint SubtSMatrixTSMatrix M;TSMatrix N;TSMatrix Q{int i;fori=1;i<=N.tu;i++N.datai.e=-1;AddSMatrixM;N;Q;return 1;}// 求稀疏矩阵的乘积Q=MNint MultSMatrixTSMatrix M;TSMatrix N;TSMatrix Q{int i;j;h=M.mu;l=N.nu;Qn=0;// h;l分别为矩阵Q的行、列值;Qn为矩阵Q的非零元素个数;初值为0 ElemType Qe;ifM.nu=N.mureturn 0;Q.mu=M.mu;Q.nu=N.nu;Qe=ElemType mallochlsizeofElemType; // Qe为矩阵Q的临时数组// 矩阵Q的第i行j列的元素值存于Qe+i-1l+j-1中;初值为0 fori=0;i<hl;i++Qe+i=0; // 赋初值0fori=1;i<=M.tu;i++ // 矩阵元素相乘;结果累加到Qeforj=1;j<=N.tu;j++ifM.datai.j==N.dataj.iQe+M.datai.i-1l+N.dataj.j-1 +=M.datai.e N.dataj.e;fori=1;i<=M.mu;i++forj=1;j<=N.nu;j++ifQe+i-1l+j-1=0{Qn++;Q.dataQn.e=Qe+i-1l+j-1;Q.dataQn.i=i;Q.dataQn.j=j;}freeQe;Q.tu=Qn;return 1;}// 算法5.1 P99// 求稀疏矩阵M的转置矩阵T..int TransposeSMatrixTSMatrix M;TSMatrix T{int p;q;col;T.mu=M.nu;T.nu=M.mu;T.tu=M.tu;ifT.tu{q=1;forcol=1;col<=M.nu;++col //先将列转换成行forp=1;p<=M.tu;++p //再将行转换成列ifM.datap.j==col{T.dataq.i=M.datap.j;T.dataq.j=M.datap.i;T.dataq.e=M.datap.e;++q;}}return 1;}// 算法5.2 P100// 快速求稀疏矩阵M的转置矩阵T..int FastTransposeSMatrixTSMatrix M;TSMatrix T{int p;q;t;col;num;cpot;num=int mallocM.nu+1sizeofint; // 生成数组0不用cpot=int mallocM.nu+1sizeofint; // 生成数组0不用T.mu=M.nu;T.nu=M.mu;T.tu=M.tu;ifT.tu{forcol=1;col<=M.nu;++colnumcol=0; // 设初值fort=1;t<=M.tu;++t // 求M中每一列含非零元素个数++numM.datat.j;cpot1=1;// 求第col列中第一个非零元在T.data中的序号forcol=2;col<=M.nu;++colcpotcol=cpotcol-1+numcol-1;forp=1;p<=M.tu;++p{col=M.datap.j;q=cpotcol;T.dataq.i=M.datap.j;T.dataq.j=M.datap.i;T.dataq.e=M.datap.e;++cpotcol;}}freenum;freecpot;return 1;}int main{TSMatrix A;B;C;printf"创建矩阵A: ";CreateSMatrix&A;PrintSMatrixA;printf"由矩阵A复制矩阵B: ";CopySMatrixA;&B;PrintSMatrixB;DestroySMatrix&B;printf"销毁矩阵B后:\n";PrintSMatrixB;printf"重创矩阵B:注意与矩阵A的行、列数相同;这样方便后面的测试""行、列分别为%d;%d\n"; A.mu; A.nu;CreateSMatrix&B;PrintSMatrixB;printf"矩阵C1A+B: ";AddSMatrixA;B;&C;PrintSMatrixC;DestroySMatrix&C;printf"矩阵C2A-B: ";SubtSMatrixA;B;&C;PrintSMatrixC;DestroySMatrix&C;printf"矩阵C3A的转置: ";TransposeSMatrixA;&C;PrintSMatrixC;DestroySMatrix&A;DestroySMatrix&B;DestroySMatrix&C;printf"创建矩阵A2: ";CreateSMatrix&A;PrintSMatrixA;printf"创建矩阵B3:行数应与矩阵A2的列数相同=%d\n";A.nu; CreateSMatrix&B;PrintSMatrixB;printf"矩阵C5AB: ";MultSMatrixA;B;&C;PrintSMatrixC;DestroySMatrix&A;DestroySMatrix&B;DestroySMatrix&C;printf"创建矩阵A: ";CreateSMatrix&A;PrintSMatrixA;FastTransposeSMatrixA;&B;printf"矩阵BA的快速转置: ";PrintSMatrixB;DestroySMatrix&A;DestroySMatrix&B;system"pause";return 0;}/输出效果：创建矩阵A: 请输入矩阵的行数;列数;非零元素个数：逗号3;3;3请按行序顺序输入第1个非零元素所在的行1～3;列1～3;元素值：逗号1;1;1请按行序顺序输入第2个非零元素所在的行1～3;列1～3;元素值：逗号1;3;2请按行序顺序输入第3个非零元素所在的行1～3;列1～3;元素值：逗号3;3;33行3列3个非零元素..行列元素值1 1 11 3 23 3 3由矩阵A复制矩阵B:3行3列3个非零元素..行列元素值1 1 11 3 23 3 3销毁矩阵B后:0行0列0个非零元素..行列元素值重创矩阵B:注意与矩阵A的行、列数相同;这样方便后面的测试行、列分别为3;3 请输入矩阵的行数;列数;非零元素个数：逗号3;3;3请按行序顺序输入第1个非零元素所在的行1～3;列1～3;元素值：逗号1;2;1请按行序顺序输入第2个非零元素所在的行1～3;列1～3;元素值：逗号2;1;2请按行序顺序输入第3个非零元素所在的行1～3;列1～3;元素值：逗号3;1;33行3列3个非零元素..行列元素值1 2 12 1 23 1 3矩阵C1A+B:3行3列6个非零元素..行列元素值1 1 11 2 11 3 22 1 23 1 33 3 3矩阵C2A-B:3行3列6个非零元素..行列元素值1 1 11 2 -11 3 22 1 -23 1 -33 3 3矩阵C3A的转置:3行3列3个非零元素..行列元素值1 1 13 1 23 3 3创建矩阵A2: 请输入矩阵的行数;列数;非零元素个数：逗号3;3;3请按行序顺序输入第1个非零元素所在的行1～3;列1～3;元素值：逗号1;1;1请按行序顺序输入第2个非零元素所在的行1～3;列1～3;元素值：逗号1;3;2请按行序顺序输入第3个非零元素所在的行1～3;列1～3;元素值：逗号3;3;33行3列3个非零元素..行列元素值1 1 11 3 23 3 3创建矩阵B3:行数应与矩阵A2的列数相同=3请输入矩阵的行数;列数;非零元素个数：逗号3;3;2请按行序顺序输入第1个非零元素所在的行1～3;列1～3;元素值：逗号1;3;1请按行序顺序输入第2个非零元素所在的行1～3;列1～3;元素值：逗号2;2;23行3列2个非零元素..行列元素值1 3 12 2 2矩阵C5AB:3行3列1个非零元素..行列元素值1 3 1创建矩阵A: 请输入矩阵的行数;列数;非零元素个数：逗号3;3;2请按行序顺序输入第1个非零元素所在的行1～3;列1～3;元素值：逗号1;2;2请按行序顺序输入第2个非零元素所在的行1～3;列1～3;元素值：逗号3;1;23行3列2个非零元素..行列元素值1 2 23 1 2矩阵BA的快速转置:3行3列2个非零元素..行列元素值1 3 22 1 2请按任意键继续. . . /。
稀疏矩阵(C语言描述)
//矩阵减法实现主模块
{
void PRINTF(RLSMatrix*Result); Result->tu=0 ; Result->mu=A->mu ; Result->nu=A->nu ; int x=1 ; int y=1 ; int z=1 ;
while(x<=A->tu) {
if(A->data[x].i<B->data[y].i) {
void PRINTF(RLSMatrix*Result);
int ctemp[MAXRC]; int tp,p,t,arow,brow,q,ccol,i ;
Result->mu=A->mu ; Result->nu=B->nu ; Result->tu=0 ; if(A->tu*B->tu!=0) {
基本操作:
第 1 页 共 12 页
－＝数据结构试验报告＝－
系数矩阵运算器
creat( ) 操作结果:以一个二维数组创建稀疏矩阵,用三元组来存储. add(RLSMatrix M , RLSMatrix N) 初始条件:稀疏矩阵 M 与 N 的行数与列数对应相等. 操 作结果:求得一个矩阵和. jian(RLSMatrix a,RLSMatrix b) 初始条件:稀疏矩阵 M 与 N 的行数与列数对应相等. 操 作结果:求得一个矩阵差. transpose(RLSMatrix M) 初始条件:稀疏矩阵 M 存在 操作结果:求稀疏矩阵 M 的转置矩阵. value(RLSMatrix M,int m,int n) 初始条件:稀疏矩阵 M 存在. 操作结果:求出三元组存储中第 m 行第 n 列的数值. print1(RLSMatrix M) 初始条件:稀疏矩阵 M 存在. 操作结果:按矩阵的形式输出
定义稀疏矩阵的三元组顺序存储结构
定义稀疏矩阵的三元组顺序存储结构下载提示：该文档是本店铺精心编制而成的，希望大家下载后，能够帮助大家解决实际问题。
文档下载后可定制修改，请根据实际需要进行调整和使用，谢谢！本店铺为大家提供各种类型的实用资料，如教育随笔、日记赏析、句子摘抄、古诗大全、经典美文、话题作文、工作总结、词语解析、文案摘录、其他资料等等，想了解不同资料格式和写法，敬请关注！Download tips: This document is carefully compiled by this editor. I hope that after you download it, it can help you solve practical problems. The document can be customized and modified after downloading, please adjust and use it according to actual needs, thank you! In addition, this shop provides you with various types of practical materials, such as educational essays, diary appreciation, sentence excerpts, ancient poems, classic articles, topic composition, work summary, word parsing, copy excerpts, other materials and so on, want to know different data formats and writing methods, please pay attention!定义稀疏矩阵的三元组顺序存储结构稀疏矩阵是指大部分元素为零的矩阵。
c语言以三元顺序表表示稀疏矩阵
C语言以三元顺序表表示稀疏矩阵1. 引言稀疏矩阵是指大部分元素为零的矩阵，通常在实际应用中占据大量存储空间。
为了高效处理稀疏矩阵，我们通常会采用三元组顺序表的方式进行表示。
本文将探讨如何使用C语言以三元顺序表表示稀疏矩阵，深入理解其原理和实现方法。
2. 稀疏矩阵的表示方法在C语言中，我们可以使用三元组顺序表来表示稀疏矩阵。
三元组顺序表包括三个部分：行号、列号和元素值。
通过这种方式，我们可以有效地压缩稀疏矩阵，节省存储空间，并且方便进行相关的运算。
3. 三元顺序表的数据结构在C语言中，我们可以使用结构体来定义三元顺序表的数据结构。
具体而言，我们可以定义一个包含行号、列号和元素值的结构体，然后通过数组来存储这些结构体，从而表示整个稀疏矩阵。
4. 如何实现C语言表示稀疏矩阵在C语言中，我们可以通过以下步骤来实现稀疏矩阵的表示：1. 定义一个结构体来存储稀疏矩阵的三元组信息。
2. 创建一个数组，用来存储这些结构体，从而表示整个稀疏矩阵。
3. 编写相关的函数，实现稀疏矩阵的压缩、展开以及相关的运算操作。
5. 样例代码下面是一段简单的C语言代码，用来表示一个稀疏矩阵，并进行相关的计算操作：```#include <stdio.h>#define MAXSIZE 12500// 定义三元组结构体typedef struct {int row;int col;int value;} Triple;// 定义稀疏矩阵typedef struct {Triple data[MAXSIZE + 1]; // 0号单元存储矩阵的行数、列数和非零元个数int mu, nu, tu; // 矩阵的行数、列数和非零元个数} TSMatrix;// 主函数int main() {// 在这里编写相关的稀疏矩阵操作return 0;}```6. 总结与展望通过本文的讨论，我们深入了解了C语言以三元顺序表表示稀疏矩阵的原理和实现方法。
稀疏矩阵的三元组表示和实现
稀疏矩阵的三元组表示和实现
稀疏矩阵是指其中大部分元素为0的矩阵。
为了节省存储空间和提高计算效率，常常使用三元组表示法来表示稀疏矩阵。
稀疏矩阵的三元组表示由三个数组组成，分别存储非零元素的行号、列号和值。
具体实现如下：
1. 定义一个结构体来表示稀疏矩阵的三元组，包括行号、列号和值。
```C++
struct SparseMatrix {
int row;
int col;
int value;
};
```
2. 创建一个数组，用来存储稀疏矩阵中的非零元素的三元组。
```C++
SparseMatrix sparseMatrix[maxSize]; // maxSize为稀疏矩阵中非零元素的个数
```
3. 初始化稀疏矩阵的三元组表示。
4. 对于每个非零元素，将其行号、列号和值存入稀疏矩阵的三元组数组中。
```C++
sparseMatrix[i].row = ...; // 非零元素的行号
sparseMatrix[i].col = ...; // 非零元素的列号
sparseMatrix[i].value = ...; // 非零元素的值
```
稀疏矩阵的三元组表示将只有非零元素的信息存储，从而节省了存储空间。
同时，通过遍历只包含非零元素的数组，可以高效地进行各种矩阵运算。
稀疏矩阵运算器的c语言实现
稀疏矩阵运算器的c语言实现
稀疏矩阵是一种特殊的矩阵，其中大部分元素都为零。
在计算机科学中，稀疏矩阵运算器是一个用于处理稀疏矩阵的工具，它可以有效地存储和操作这些矩阵，以节省内存和计算资源。
为了实现稀疏矩阵运算器，我们可以使用C语言来编写相应的程序。
首先，我们需要设计一种数据结构来表示稀疏矩阵。
一种常见的方法是使用三元组表示法，即将非零元素的值、行号和列号存储在一个结构体中。
接下来，我们需要实现一些基本的运算操作，如矩阵的加法、减法和乘法。
对于加法和减法，我们可以遍历两个矩阵的非零元素，并将它们相加或相减。
对于乘法，我们可以使用稀疏矩阵的特性来减少计算量，只计算非零元素的乘积。
我们还可以实现一些其他的操作，如转置、求逆和求行列式等。
这些操作可以根据具体需求来扩展，以满足用户的需求。
在编写程序时，我们需要注意算法的效率和内存的使用。
由于稀疏矩阵的特殊性，我们可以使用一些优化技术来提高计算速度和节省内存。
例如，我们可以使用链表来存储非零元素，而不是使用二维数组，以减少存储空间。
我们还可以使用稀疏矩阵的特殊性来设计更高效的算法。
稀疏矩阵运算器是一个重要的工具，它可以在处理大型稀疏矩阵时
提供高效的计算和存储。
通过合理设计数据结构和算法，我们可以实现一个功能强大且高性能的稀疏矩阵运算器，以满足各种应用场景的需求。
数据结构-稀疏矩阵的三元组表存储方法
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 的三元组；三实验内容:稀疏矩阵的抽象数据类型: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+NSubSMatrix(M, N, &Q)初始条件：稀疏矩阵M、N已经存在操作结果：求矩阵的差Q=M-N TransposeSMatrix(M, & T)初始条件：稀疏矩阵M已经存在操作结果：求矩阵M的转置T MultSMatrix(M, N, &Q)初始条件：稀疏矩阵M已经存在操作结果：求矩阵的积Q=M*N}ADT SparseMatrix存储结构的定义#define N 4typedef int ElemType;#define MaxSize 100 =i;[].c=j;[].d=A[i][j];++;}}}void DispMat(TSMatrix t){int i;if <=0)return;printf("\t%d\t%d\t%d\n",,,;printf("\t------------------\n");for (i=0;i<;i++)printf("\t%d\t%d\t%d\n",[i].r,[i].c,[i].d); }解题思路：1.转置矩阵：只要判定原矩阵有值，那么只要遍历一遍原矩阵，把原来矩阵中非0元素行列变换一下赋值到新的矩阵中即可。
数据结构C语言版-稀疏矩阵三元组的基本操作讲解学习
1.3设计要求
学会分析研究计算机加工的数据结构的特性，以便为应用涉及的数据选择适当的逻辑结构，存储结构及其相应的算法，算法要求用C语言完成。学生独立思考解决问题为主，教师指导为辅，结合上机操作，完成指定的任务，撰写课程设计报告。要求源代码有足够的注释，能达到题目要求，并使人能看得懂你的代码。
3.2题目内容…………………………………………………………………………………...6
3.3题目分析…………………………………………………………………………………...6
4．概要设计………………………………………………………………………………….7
4.1稀疏矩阵存储结构………………………………………………………………………..7
数据结构C语言版-稀疏矩阵三元组的基本操作
数据结构
课程设计实验报告
内容名称：稀疏矩阵的基本操作
成员1：09213020-陈东
成员2：09213040-Fra bibliotek丹班级：09数31
教师：李晓翠
江苏师范大学
数学科学学院
1.序言…………………….........................................................................................................3
基于此原因，我们开设了数据结构课程设计。针对数据结构课程的特点，着眼于培养我们的实践能力。实习课程是为了加强编程能力的培养，鼓励学生使用新兴的编程语言。相信通过数据结构课程实践，无论是理论知识，还是实践动手能力，同学们都会有不同程度上的提高。
1.2课程设计的目的
巩固和深刻理解“数据结构（C语言版）”课程所讲解的C语言作为数据结构的算法的描述，掌握对数据的存储结构和算法进行描述时，尽量考虑C语言的特色。培养学生独立工作和创新思维的能力，取得设计与调试的实践经验。提高和加强计算机应用及软件开发能力。通过课程设计题目的练习，强化学生对所学知识的掌握及对问题分析和任务定义的理解，对每到题目作出了相应的逻辑分析和数据结构的选择，通过对任务的分析，为操作对象定义相应的数据结构，以过程化程序设计的思想方法为原则划分各个模块，定义数据的抽象数据类型。分模块对题目进行设计，强化学生对C语言的掌握和对数据结构的选择及掌握。通过程序的编译掌握对程序的调试方法及思想，并且让学生学会使用一些编程技巧。促使学生养成良好的编程习惯，以及让学生对书本上的知识进行了实践。算法与数据结构这门课是计算机科学中一门综合性的专业基础课
数据结构-稀疏矩阵的三元组表存储方法
M=
注意:用变量 和 分别存放矩阵 注意 用变量a和 b分别存放矩阵 用变量 M和N (TSMatrix a, TSMatrix b), 和 即要从已知变量a来求得变量 来求得变量b的 即要从已知变量 来求得变量 的 值。
也既要完成如下求解工作： 也既要完成如下求解工作：
a . data p a .data 1 a .data 2 a .data 3 a .data 4 a .data 5 a .data 6 a .data 7 a .data 8 i 1 1 3 3 4 5 6 6 j 2 3 1 6 3 2 1 4 e 12 9 -3 14 24 18 15 -7 b . data q b .data 1 b .data 2 b .data 3 i 1 1 2 2 3 3 4 6 j 3 6 1 5 1 4 6 3 e -3 15 12 18 9 24 -7 14
求得
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,寻找 j=col 的a.data[ p] 寻找
2.求解步骤分析：p=1:8, q的值 求解步骤分析： 的值=8 求解步骤分析 的值
a . data p a .data 1 a .data 2 a .data 3 a .data 4 a .data 5 a .data 6 a .data 7 a .data 8 i 1 1 3 3 4 5 6 6 j 2 3 1 6 3 2 1 4 e 12 9 Col=6 -3 14 求得 24 18 15 -7 b . data q b .data 1 b .data 2 b .data 3 b .data 4 b .data 5 b .data 6 b .data 7 b .data 8 i 1 1 2 2 3 3 4 6 j 3 6 1 5 1 4 6 e -3 15 12 18 9 24 -7
c语言稀疏矩阵应用代码实现三元组,十字链表下的稀疏矩阵的加、转、乘的实现。
c语言稀疏矩阵应用代码实现三元组，十字链表下的稀疏矩阵的加、转、乘的实现。
在C语言中，实现稀疏矩阵的加法、转置和乘法涉及复杂的数据结构和算法。
其中，常用的表示稀疏矩阵的两种数据结构是三元组和十字链表。
下面我将为您提供一个简单的示例代码，用C语言实现稀疏矩阵的加法、转置和乘法操作，使用三元组表示法来表示稀疏矩阵。
首先，我们需要定义表示稀疏矩阵的三元组结构体：```c#include<stdio.h>#define MAX_SIZE100typedef struct{int row;int col;int value;}Element;typedef struct{int rows;int cols;int num_elements;Element data[MAX_SIZE];}SparseMatrix;```接下来，我们实现稀疏矩阵的加法、转置和乘法函数：```c#include<stdbool.h>//加法函数SparseMatrix addSparseMatrix(SparseMatrix matrix1,SparseMatrix matrix2){ SparseMatrix result;result.rows=matrix1.rows;result.cols=matrix1.cols;result.num_elements=0;int i=0,j=0;while(i<matrix1.num_elements&&j<matrix2.num_elements){if(matrix1.data[i].row<matrix2.data[j].row||(matrix1.data[i].row==matrix2.data[j].row&&matrix1.data[i].col<matrix2.data[j].col)){ result.data[result.num_elements++]=matrix1.data[i++];}else if(matrix1.data[i].row>matrix2.data[j].row||(matrix1.data[i].row==matrix2.data[j].row&&matrix1.data[i].col>matrix2.data[j].col)){ result.data[result.num_elements++]=matrix2.data[j++];}else{Element element;element.row=matrix1.data[i].row;element.col=matrix1.data[i].col;element.value=matrix1.data[i].value+matrix2.data[j].value;if(element.value!=0){result.data[result.num_elements++]=element;}i++;j++;}}while(i<matrix1.num_elements){result.data[result.num_elements++]=matrix1.data[i++];}while(j<matrix2.num_elements){result.data[result.num_elements++]=matrix2.data[j++];}return result;}//转置函数SparseMatrix transposeSparseMatrix(SparseMatrix matrix){ SparseMatrix result;result.rows=matrix.cols;result.cols=matrix.rows;result.num_elements=matrix.num_elements;int count[matrix.cols];int index[matrix.cols];for(int i=0;i<matrix.cols;i++){count[i]=0;}for(int i=0;i<matrix.num_elements;i++){count[matrix.data[i].col]++;}index[0]=0;for(int i=1;i<matrix.cols;i++){index[i]=index[i-1]+count[i-1];}for(int i=0;i<matrix.num_elements;i++){int j=index[matrix.data[i].col];result.data[j].row=matrix.data[i].col;result.data[j].col=matrix.data[i].row;result.data[j].value=matrix.data[i].value;index[matrix.data[i].col]++;}return result;}//乘法函数SparseMatrix multiplySparseMatrix(SparseMatrix matrix1,SparseMatrix matrix2){ SparseMatrix result;if(matrix1.cols!=matrix2.rows){result.rows=0;result.cols=0;result.num_elements=0;return result;}result.rows=matrix1.rows;result.cols=matrix2.cols;result.num_elements=0;bool visited[matrix2.cols];for(int i=0;i<matrix2.cols;i++){visited[i]=false;}for(int i=0;i<matrix1.num_elements;i++){for(int j=0;j<matrix2.num_elements;j++){if(matrix1.data[i].col==matrix2.data[j].row){Element element;element.row=matrix1.data[i].row;element.col=matrix2.data[j].col;element.value=matrix1.data[i].value*matrix2.data[j].value; result.data[result.num_elements++]=element;visited[matrix2.data[j].col]=true;}}}for(int i=0;i<matrix2.cols;i++){if(!visited[i]){for(int j=0;j<matrix1.rows;j++){Element element;element.row=j;element.col=i;element.value=0;result.data[result.num_elements++]=element;}}}return result;}```请注意，上述代码只是一个简单示例，实际应用中可能需要根据具体需求进行优化和扩展。
数据结构C语言版-稀疏矩阵的三元组顺序表存储表示和实现
typeｄef int EｌemTｙpｅ;// 稀疏矩阵得三元组顺序表存储表示#define ＭＡXＳIZＥ 1０0 ／/ 非零元个数得最大值tyｐedef strｕcｔ｛iｎt i,j；ﻩ／/ 行下标，列下标ﻩＥlｅmType e；// 非零元素值}Triｐle；typeｄef ｓtruct｛Triple dａta[ＭＡXＳＩＺE+1］；／/ 非零元三元组表，datａ[0］未用ﻩｉnt ｍu，ｎu，ｔｕ；ﻩﻩ/／矩阵得行数、列数与非零元个数}TＳMａtrｉx；／/ 创建稀疏矩阵Ｍint CreateSMatrｉx(TＳMatrix *M）｛ﻩinｔｉ,m，n；ﻩElemＴｙpe e;ﻩint k；printf("请输入矩阵得行数，列数，非零元素个数：(逗号）\ｎ”）;ﻩscanf（”％d，％d，％d”，＆(＊M）、mu，&（*M）、nu，＆（*M）、tu）;（＊Ｍ）、data[0]、i＝0；ﻩ// 为以下比较顺序做准备ﻩｆor（i = 1；ｉ〈＝ (＊M)、tu; i++)ﻩ｛ﻩdｏﻩﻩ{ﻩﻩﻩpｒｉntf("请按行序顺序输入第％ｄ个非零元素所在得行（１~%d），＂ﻩﻩ＂列(1～％d），元素值:（逗号)\n", i,(*M）、mu，（*M)、nｕ）；ﻩﻩscａnｆ（＂%d，%d，％d＂，＆m,＆n，＆e)；ﻩk＝０;ﻩﻩ/／行或列超出范围if(m 〈 1 ｜｜m 〉（*M)、mｕ |｜ｎ＜ 1 |｜n > （＊M)、nu）ﻩﻩk=1;ﻩﻩif（m ＜（＊M)、data［i—１］、i ｜｜ｍ＝= (＊M）、datａ［i-1]、ｉﻩﻩ&＆n <= (*M）、dａｔa［i—１]、j） // 行或列得顺序有错ﻩﻩk=1；ﻩ｝while（k)；ﻩ（＊Ｍ）、daｔa[i]、i = ｍ；／/行下标(*M)、datａ［i]、j ＝ n；//列下标（＊M）、data［i]、ｅ = e；ﻩ//该下标所对应得值｝return 1；}// 销毁稀疏矩阵M,所有元素置空voiｄ DesｔｒoyＳＭａｔrix(TSＭatｒix *Ｍ）{ﻩ（＊M）、mu=0；ﻩ（＊M)、nu=0；ﻩ（＊M）、tｕ＝０；}／/ 输出稀疏矩阵MvoｉｄPrintＳMatriｘ(TSMatrｉｘM){int i；ﻩprｉnｔf("＼n％d行%d列％ｄ个非零元素。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
数据结构课程设计实验报告内容名称：稀疏矩阵的基本操作成员1：09213020-陈东成员2：09213040-蔡丹班级：09数31教师：***江苏师范大学数学科学学院目录1.序言 (3)1.1数据结构背景 (3)1.2课程设计目的 (3)1.3 课程名称 (3)1.4设计要求 (3)1.5设计说明 (3)2．课程任务设计说明书 (5)3.需求分析 (6)3.1题目名称 (6)3.2题目内容 (6)3.3题目分析 (6)4．概要设计 (7)4.1稀疏矩阵存储结构 (7)4.2.稀疏矩阵的基本操作 (7)4.3各模块设计要求 (8)4.4总体功能流程图 (9)4.4.1存储结构流程图 (9)4.4.2稀疏矩阵基本操作流程图 (10)5．详细设计 (11)5.1设计原理 (11)5.2基本函数实现流程图 (13)6．主要函数代码 (21)7．调试与操作说明 (27)7.1操作说明 (27)7.2调试结果………………………………………………………………………………. ..287.3结果分析 (31)8.设计体会 (32)9.参考文献 (32)10.分工说明 (33)1.序言1.1数据结构背景数据结构是一门理论性强、思维抽象、难度较大的课程，是基础课和专业课之间的桥梁。
该课程的先行课程是计算机基础、程序设计语言、离散数学等，后续课程有操作系统、编译原理、数据库原理、软件工程等。
通过本门课程的学习，我们应该能透彻地理解各种数据对象的特点，学会数据的组织方法和实现方法，并进一步培养良好的程序设计能力和解决实际问题的能力，而且该课程的研究方法对我们学生在校和离校后的学习和工作，也有着重要的意义。
数据结构是计算机科学与技术专业的一门核心专业基础课程，在该专业的课程体系中起着承上启下的作用，学好数据结构对于提高理论认知水平和实践能力有着极为重要的作用。
学习数据结构的最终目的是为了获得求解问题的能力。
对于现实世界中的问题，应该能从中抽象出一个适当的数学模型，该数学模型在计算机内部用相应的数据结构来表示，然后设计一个解此数学模型的算法，再进行编程调试，最后获得问题的解答。
基于此原因，我们开设了数据结构课程设计。
针对数据结构课程的特点，着眼于培养我们的实践能力。
实习课程是为了加强编程能力的培养，鼓励学生使用新兴的编程语言。
相信通过数据结构课程实践，无论是理论知识，还是实践动手能力，同学们都会有不同程度上的提高。
1.2课程设计的目的巩固和深刻理解“数据结构（C语言版）”课程所讲解的C语言作为数据结构的算法的描述，掌握对数据的存储结构和算法进行描述时，尽量考虑C 语言的特色。
培养学生独立工作和创新思维的能力，取得设计与调试的实践经验。
提高和加强计算机应用及软件开发能力。
通过课程设计题目的练习，强化学生对所学知识的掌握及对问题分析和任务定义的理解，对每到题目作出了相应的逻辑分析和数据结构的选择，通过对任务的分析，为操作对象定义相应的数据结构，以过程化程序设计的思想方法为原则划分各个模块，定义数据的抽象数据类型。
分模块对题目进行设计，强化学生对C语言的掌握和对数据结构的选择及掌握。
通过程序的编译掌握对程序的调试方法及思想，并且让学生学会使用一些编程技巧。
促使学生养成良好的编程习惯，以及让学生对书本上的知识进行了实践。
算法与数据结构这门课是计算机科学中一门综合性的专业基础课1.2课程名称：数据结构1.3设计要求学会分析研究计算机加工的数据结构的特性，以便为应用涉及的数据选择适当的逻辑结构，存储结构及其相应的算法，算法要求用C语言完成。
学生独立思考解决问题为主，教师指导为辅，结合上机操作，完成指定的任务，撰写课程设计报告。
要求源代码有足够的注释，能达到题目要求，并使人能看得懂你的代码。
1.5设计说明此课程设计着重在于让我们理解如何利用C语言来实现稀疏矩阵的一些具体操作，里面代码完全采用C语言描述，包括了稀疏矩阵的建立，稀疏矩阵的输出，两个稀疏矩阵的相加，以及如何求出相应矩阵的转置矩阵。
由于在我们课本中除了学习了稀疏矩阵的建立，相加，转置外，我们还接触了稀疏矩阵的销毁，稀疏矩阵的复制，稀疏矩阵的相减，稀疏矩阵的相乘，为了将有关稀疏矩阵的几个基本操作全部实现一遍，我们在完成原有题目的要求下，拓展了下题目内容，将稀疏矩阵的销毁，稀疏矩阵的复制，稀疏矩阵的相减，稀疏矩阵的相乘补充进去，这样我们更觉得此次课程设计的完整性。
而且，为了使读者更容易理解代码含义，程序的源代码基本与书本同步，思想方法也基本与书本介绍的吻合！2．课程设计任务书3．需求分析3.1题目名称：稀疏矩阵的操作3.2题目内容：1.稀疏矩阵采用三元组表示；2.求两个具有相同行列数的稀疏矩阵A和B的相加矩阵C，并输出C；3.求出A的转置矩阵D，输出D；题目拓展：4.稀疏矩阵的销毁5.稀疏矩阵的快速转置6.求两个具有相同行列数的稀疏矩阵A和B的相减矩阵C，并输出C；7.求两个具有相同行列数的稀疏矩阵A和B的相乘矩阵C，并输出C；3.3题目分析：通常，用高级语言编制程序时，都是用二维数组来存储矩阵元。
有的程序设计语言中还提供了各种矩阵运算，用户使用时都很方便。
然而，在数值分析中经常出现一些阶数很高的矩阵，同时在矩阵中有许多值相同的元素或者零元素。
有的为了节省存储空间，可以对这类矩阵进行压缩存储。
所谓压缩存储是指：为多个值相同的元只分配一个存储空间；对零元不分配空间。
我们可以运用压缩存储的方式来实现稀疏矩阵的几个基本操作。
4.概要设计4.1稀疏矩阵存储结构#define MAXSIZE 12500 //假设非零元个数的最大值为12500 typedef struct{int i ，j；//该非零元的行下标和列下标ElemeType e；}Triple;Typedef struct{Triple data[MAXSIZE+1]；//非零元三元组表，data[0]未用int mu ，nu，tu；//矩阵的行数，列数和非零元个数}TSMatrix；4.2.稀疏矩阵的基本操作CreateSMatrix(&M);操作结果：创建稀疏矩阵M。
DestroySMatrix(&M)；初始条件：稀疏矩阵M存在；操作结果：销毁稀疏矩阵M。
PrintSMatrix( M)初始条件：稀疏矩阵M存在。
操作结果：输出稀疏矩阵M。
CopySMatrix(TSMatrix M,TSMatrix *T)初始条件：稀疏矩阵M存在操作结果：由稀疏矩阵M复制得到T。
AddSMatrix(TSMatrix M,TSMatrix N,TSMatrix *Q)初始条件：稀疏矩阵M与N的行数和列数对应相等。
操作结果：求稀疏矩阵的和Q=M+N.SubtSMatrix(TSMatrix M,TSMatrix N,TSMatrix *Q)初始条件：稀疏矩阵M与N的行数和列数对应相等。
操作结果：求稀疏矩阵的和Q=M-N.MultSMatrix(TSMatrix M,TSMatrix N,TSMatrix *Q)初始条件：稀疏矩阵M与N的行数和列数对应相等。
操作结果：求稀疏矩阵的和Q=M*N.TransposeSMatrix(TSMatrix M,TSMatrix *T)初始条件：稀疏矩阵M存在操作结果：由稀疏矩阵M的转置矩阵T4.3.各模块设计要求1.初始函数建立稀疏矩阵及初始化稀疏矩阵本模块要求设计函数在三元组顺序表中建立稀疏矩阵并初始化。
首先要定义三元组表结构体类型，在输入出现错误时，能够对错误进行判别处理，初始化稀疏矩阵都为空值，特别需要注意在三元组表存储稀疏矩阵的时候，要对变量进行动态的地址分配2.转置函数进行稀疏矩阵的转置本模块要求设计函数进行稀疏矩阵的转置并输出转置后的结果，由于对稀疏矩阵的转置只对一个矩阵进行操作，所以实现起来难度并不是很大，函数也比较容易编写。
在编写函数时，首先定义一个相应的结构体变量用于存放转置后的矩阵，最后把此矩阵输出。
3.和运算函数进行两个稀疏矩阵相加运算本模块要求设计加法对两个矩阵进行运算，并输出最终运算后的稀疏矩阵，在进行运算前，要对两个矩阵进行检查，看是不是相同类型的矩阵，因为两个矩阵相加要求两个矩阵一定是同一类型的矩阵，定义相应的矩阵类型用于存放两个矩阵相加的结果矩阵，这个结果矩阵的行数列数要综合多方面来确定。
4.积运算函数进行两个稀疏矩阵的乘法运算本模块要求设计乘法对两个矩阵进行运算，并输出最终运算后的稀疏矩阵，在进行运算前，要对两个矩阵进行检查，如果A矩阵的行（列）和B矩阵列（行）数值相等，则能完成相应的乘法运算，定义相应的矩阵类型用于存放两个稀疏矩阵相乘之后的结果矩阵，并且调用输出函数完成乘积的输出5输出函数完成矩阵的输出本模块要求完成对稀疏矩阵的输出功能，实现起来比较简单，完成矩阵的转置输出，矩阵的加法，减法，乘法运算输出相应的和，差，积，都要调用输出函数。
4.4总体功能流程图4.4.1存储结构流程图：4.4.2稀疏矩阵基本操作流程图：5．详细设计5.1设计原理1.三元组顺序表：假设以顺序存储结构来表示三元组表，则可得稀疏矩阵的一种压缩存储方式——我们称之为三元组顺序表。
因此，data域中表示非零的三元组是以行序为主序顺序排列的。
按照压缩存储的概念，只存储稀疏矩阵的非零元。
因此，除了存储非零元的值外，还必须同时记下它所在行和列的位置（i，j）。
反之，一个三元组（i，j，aij）唯一确定了矩阵A的一个非零元。
由此，稀疏矩阵可由表示非零元的三元组及其行列数唯一确定。
例如，下列三元组表：（（1,2,1），（1,3,9），（3,1,3），（3,6,14），（4,3,4），（5,2,8），（6,1,5），（6,4,7）），于是稀疏矩阵A可以描述为：0 1 9 0 0 0 00 0 0 0 0 0 0A= 3 0 0 0 0 4 00 0 4 0 0 0 00 8 0 0 0 0 05 0 0 7 0 0 02.矩阵转置：转置运算是一种简单的矩阵运算。
对于一个m*n的矩阵M，它的转置矩阵T是一个n*m的矩阵，且T(i,j)=M(j,i)。
显然，一个稀疏矩阵的转置仍为稀疏矩阵：要想实现矩阵之间的转置，只要做到：(1)将矩阵的行列值相互交换；(2)将每个三元组中的i和j相互调换；(3)重排三元组之间的次序便可实现矩阵的转置。
前二条内容是容易做到的，关键是如何实现第三条，我们有2种方法，在这我们使用以下方法实现：我们按照矩阵M的列序来进行转置，为了找到M的每一列中所有的非零元素，需要对其三元组表a.data 从第一行起整个扫描一遍，由于a.data是以M的行序为主序来存放每个非零元的，由此得到的恰是b.data应用的顺序。
a.datab.data3 .两个稀疏矩阵相加：比较满足条件（行数及列数都相同的2个矩阵）的两个稀疏矩阵中不为0的元素的行数及列数（即i与j），将i与j都相等的前后两个元素e相加，保持i，j不变存储在新的三元组中，不等的则分别储存在此新三元组中。