三元组实现矩阵相加

三元组表稀疏矩阵其求和

#include "stdio.h"#define MAXSIZE 100struct node{int i,j;int v;};struct sparmatrix{int rows,cols;int terms;struct node data[MAXSIZE];};void sum(struct sparmatrix a,struct sparmatrix b);main(){int m[MAXSIZE][MAXSIZE],n[MAXSIZE][MAXSIZE];int i,j,mrow,mcol,nrow,ncol,ano=0,bno=0,counter=0,t=0;struct sparmatrix a,b;printf("Please input row and col of matrix m(for example: row,col):"); scanf("%d,%d",&mrow,&mcol);printf("\n");printf("Please input row and col of matrix n(for example: row,col):"); scanf("%d,%d",&nrow,&ncol);if ((mrow!=nrow)||(mcol!=ncol)){printf("ERROR: dimensions of m,n are different!");getch();return; /*comapre dimension between matrix m and n*/ }for (i=0;i<mrow;i++)for (j=0;j<mcol;j++){ printf("input value of data element m[%d][%d] ",i,j);scanf("%d",&m[i][j]);} /*input value of matrix m*/for (i=0;i<nrow;i++)for (j=0;j<ncol;j++){ printf("input value of data element n[%d][%d] ",i,j);scanf("%d",&n[i][j]);} /*input value of matrix n*/printf("matrix m you input as follows:\n");for (i=0;i<mrow;i++)for (j=0;j<mcol;j++){if (t==mcol){printf("\n");t=0;}printf(" %d",m[i][j]);t++;} /*output matrix m*/printf("\n");printf("\n");printf("matrix n you input as follows:\n");t=0;for (i=0;i<nrow;i++)for (j=0;j<ncol;j++){if (t==ncol){printf("\n");t=0;}printf(" %d",n[i][j]);t++;} /*output matrix n*/printf("\n");printf("\n");for (i=0;i<mrow;i++)for (j=0;j<mcol;j++)if (m[i][j]!=0){ counter++;a.data[ano].i=i;a.data[ano].j=j;a.data[ano].v=m[i][j];ano++;}a.rows=mrow;a.cols=mcol;a.terms=counter;printf("tripule node of m: i j v \n");for(i=0;i<a.terms;i++)printf(" %5d %5d %5d\n",a.data[i].i,a.data[i].j,a.data[i].v);counter=0;for (i=0;i<nrow;i++)for (j=0;j<ncol;j++)if (n[i][j]!=0){ counter++;b.data[bno].i=i;b.data[bno].j=j;b.data[bno].v=n[i][j];bno++;}b.rows=nrow;b.cols=ncol;b.terms=counter;printf("tripule node of n: i j v\n");for(i=0;i<b.terms;i++)printf(" %5d %5d %5d\n",b.data[i].i,b.data[i].j,b.data[i].v);sum(a,b);getch();}void sum(struct sparmatrix a,struct sparmatrix b){struct sparmatrix c; /*c为a+b的转置*/int i,j,x,k=0,p=0,cno=0,counter=0,flag=0;int mn[MAXSIZE][MAXSIZE]; /*define variables*/c.cols=a.cols;c.rows=a.rows;if (a.terms==0&&b.terms==0){return ; /*check the numbers of data element that isn't zero*/}for(i=1;i<=c.rows;i++){for(j=1;j<=c.cols;j++){if(a.data[k].i==b.data[p].i)if(a.data[k].j==b.data[p].j){c.data[cno].v=a.data[k].v+b.data[p].v;c.data[cno].i=a.data[k].i;c.data[cno].j=a.data[k].j;cno++;k++;p++;}elseif(a.data[k].j>b.data[p].j){c.data[cno].v=b.data[p].v;c.data[cno].i=b.data[p].i;c.data[cno].j=b.data[p].j;cno++;p++;}else{c.data[cno].v=a.data[k].v;c.data[cno].i=a.data[k].i;c.data[cno].j=a.data[k].j;cno++;k++;}elseif(a.data[k].i>b.data[p].i){c.data[cno].v=b.data[p].v;c.data[cno].i=b.data[p].i;c.data[cno].j=b.data[p].j;cno++;p++;}else{c.data[cno].v=a.data[k].v;c.data[cno].i=a.data[k].i;c.data[cno].j=a.data[k].j;cno++;k++;};if (k==a.terms||p==b.terms){flag=1;break;}}if (flag==1)break;}if(k==a.terms&&p<b.terms)while(p<b.terms){c.data[cno].v=b.data[p].v;c.data[cno].i=b.data[p].i;c.data[cno].j=b.data[p].j;cno++;p++;}if(p==b.terms&&k<a.terms)while(k<a.terms){c.data[cno].v=a.data[k].v;c.data[cno].i=a.data[k].i;c.data[cno].j=a.data[k].j;cno++;k++;}if(k==a.terms&&p==b.terms)c.terms=cno;printf("the tripule of m+n is: i j v \n");for(i=0;i<c.terms;i++)printf(" %5d %5d %5d\n",c.data[i].i,c.data[i].j,c.data[i].v);for (i=0;i<c.rows;i++)for (j=0;j<c.cols;j++)mn[i][j]=0;for (i=0;i<c.rows;i++)for (j=0;j<c.cols;j++)for (x=0;x<c.terms;x++)if (i==c.data[x].i)if(j==c.data[x].j)mn[i][j]=c.data[x].v;printf("\n");printf("sum of matrix m+n as follows:\n");for (i=0;i<c.rows;i++)for (j=0;j<c.cols;j++){if (counter==c.cols){printf("\n");counter=0;}printf(" %d",mn[i][j]);counter++;}}。

三元组顺序结构实现稀疏矩阵相加，行序优先（Java语言描述）

三元组顺序结构实现稀疏矩阵相加，⾏序优先（Java语⾔描述）不⽤⼗字链表也可以稀疏矩阵相加时间复杂度最坏情况达到O(tuA + tuB);思路⽐较简单就不赘述了，代码如下：三元组：package ⾏逻辑链接的顺序表实现稀疏矩阵的相乘;public class Triple<T> {int row,col;T v;public Triple(){}public Triple(int row,int col, T v){this.row = row;this.col = col;this.v = v;}}构建矩阵存储结构：package ⾏逻辑链接的顺序表实现稀疏矩阵的相乘;public class Mat {final int MAXSIZE = 10;int mu,nu,tu;int rpos[] = new int[MAXSIZE + 1];//各⾏第⼀个⾮零元的位置表Triple<Integer> data[] = new Triple[MAXSIZE + 1];//Java不⽀持泛型数组public Mat(int mu,int nu,int tu){this.mu = mu;this.nu = nu;this.tu = tu;for(int i=1; i<=MAXSIZE; i++)data[i] = new Triple();}//三元组矩阵的输出public void display(){int i,j,k,m,n,count = 0;for(i=1; i<=mu; i++){for(j=1; j<=nu; j++){for(k=1; k<=tu; k++){if(i==data[k].row && j==data[k].col){System.out.print(data[k].v + " ");count = -1;break;}}if(count != -1)System.out.print("0 ");count = 0;}System.out.println();}}}相加：package ⾏逻辑链接的顺序表实现稀疏矩阵的相乘;import java.util.*;public class AddMat {public static void main(String[] args) {/** @author 王旭* @time 2014/10/14/23:50**/Scanner scan = new Scanner(System.in);int muA,nuA,tuA,muB,nuB,tuB;System.out.println("请输⼊A矩阵的⾏，列，⾮零元的个数：");muA = scan.nextInt();nuA = scan.nextInt();tuA = scan.nextInt();Mat A = new Mat(muA,nuA,tuA);System.out.println("请输⼊A矩阵的三元组：");for(int i=1; i<=tuA; i++){A.data[i].row = scan.nextInt();A.data[i].col = scan.nextInt();A.data[i].v = scan.nextInt();}System.out.println("A矩阵为：");A.display();System.out.println("请输⼊B矩阵的⾏，列，⾮零元的个数：");muB = scan.nextInt();nuB = scan.nextInt();tuB = scan.nextInt();Mat B = new Mat(muB,nuB,tuB);System.out.println("请输⼊B矩阵的三元组：");for(int i=1; i<=tuB; i++){B.data[i].row = scan.nextInt();B.data[i].col = scan.nextInt();B.data[i].v = scan.nextInt();}System.out.println("B矩阵为：");B.display();Mat C = new Mat(muA,nuA,1);add(A,B,C);System.out.println("相加后的矩阵C为：");C.display();}public static void add(Mat A, Mat B, Mat C){int k,l,temp;//C = new Mat(A.mu,A.nu,1);k = 1;l = 1;while(k<A.tu && l<B.tu){if((A.data[k].row == B.data[l].row) && (A.data[k].col == B.data[l].col)){temp = A.data[k].v + B.data[l].v;if(temp != 0){C.data[C.tu].row = A.data[k].row;C.data[C.tu].col = A.data[k].col;C.data[C.tu].v = temp;C.tu++;}k++;l++;}if(( (A.data[k].row == B.data[l].row) && (A.data[k].col < B.data[l].col) ) || (A.data[k].row<B.data[l].row)){ C.data[C.tu].row = A.data[k].row;C.data[C.tu].col = A.data[k].col;C.data[C.tu].v = A.data[k].v;C.tu++;k++;}if(( (B.data[l].row == A.data[k].row) && (B.data[l].col < A.data[k].col) ) || (B.data[l].row<A.data[k].row)){ C.data[C.tu].row = B.data[l].row;C.data[C.tu].col = B.data[l].col;C.data[C.tu].v = B.data[l].v;C.tu++;l++;}}}}。

三元组实现矩阵相加

//从文本读入矩阵，将其转化为三元组矩阵，并做矩阵相加//矩阵转置是个难点，要提高效率以下存入trematrix1.txt中7 8 81 2 51 4 62 6 42 7 24 2 15 6 216 7 5以下存入trematrix2.txt中9 8 82 5 94 1 84 2 85 6 47 2 98 5 108 7 55源程序如下：#include<stdio.h>#include<stdlib.h>typedef int datatype;typedef struct{datatype data[30][3];int size;}thrematrix;typedef thrematrix* matrix3;typedef struct{int data[100][100];int row,col;//存储稀疏矩阵，行为ROW 列为COL}matrix;typedef matrix * matr;int posi=1,posj=1;void readfile(FILE *fp,matrix3 mat){//从文件读取三元组矩阵int row,col;//存储稀疏矩阵的行和列int i,j;fscanf(fp,"%d%d%d",&mat->data[0][0],&mat->data[0][1],&mat->data[0 ][2]);mat->size=mat->data[0][2];for(i=1;i<mat->size;i++){fscanf(fp,"%d%d%d",&mat->data[i][0],&mat->data[i][1],&mat->data[i ][2]);}fclose(fp);}void prmatrix(matrix3 mat){ //打印该三元组矩阵int i,j;printf("\n三元组矩阵为：\n");for(i=0;i<mat->data[0][2];i++){for(j=0;j<3;j++)printf("%4d",mat->data[i][j]);printf("\n");}}void transpose(matr mat,matrix3 b,matrix3 c){//基于三元组矩阵的转置//将B三元组转化为C三元组int k;k=b->data[0][2];int i,j,x[k];//表示矩阵中的某一行有多少个元素int pos[k];//此B[i][]的起始位置是多少c->data[0][0]=b->data[0][1];c->data[0][1]=b->data[0][0];c->data[0][2]=b->data[0][2];c->size=b->size;for(i=0;i<k;i++)//取列{pos[i]=0;x[i]=0;}for(i=1;i<k;i++)//若列不为零则x[][]++{//保存B->data[i][1]中的列中有多少个元素x[b->data[i][1]]++;}pos[0]=1;for(i=1;i<k;i++)pos[i]=pos[i-1]+x[i-1];//计算出每个元素要插入的位置！for(i=1;i<k;i++){int t;t=pos[b->data[i][1]];c->data[t][0]=b->data[i][1];c->data[t][1]=b->data[i][0];c->data[t][2]=b->data[i][2];pos[b->data[i][1]]=t+1;//计数// printf("|%d",pos[t]);// printf("=%d| \n",pos[t]+count[t]);}/* printf("\n"); printf("xi=");for(i=0;i<k;i++)//测试打印printf(" %d",x[i]);printf("\n");printf("posi=");for(i=0;i<k;i++)//测试打印printf(" %d",pos[i]);printf("\n");*/}int judge(matrix3 m1,matrix3 madd,matrix3 m3,int k) {int k10=m1->data[posi][0];int k11=m1->data[posi][1];int k12=m1->data[posi][2];int k30=m3->data[posj][0];int k31=m3->data[posj][1];int k32=m3->data[posj][2];// printf(" %d",k);if(k10==k30){if(k11==k31){madd->data[k][0]=k10;madd->data[k][1]=k11;madd->data[k][2]=k12+k32; posi++;posj++;return k;}if(k11>k31){madd->data[k][0]=k30;madd->data[k][1]=k31;madd->data[k][2]=k32;posj++;return k;}else{madd->data[k][0]=k10;madd->data[k][1]=k11;madd->data[k][2]=k12;posi++;return k;}}if(k10>k30){madd->data[k][0]=k30;madd->data[k][1]=k31;madd->data[k][2]=k32;posj++;return k;}if(k30>k10){madd->data[k][0]=k10; madd->data[k][1]=k11;madd->data[k][2]=k12;posi++;return k;}}void matrixadd1(matrix3 m1,matrix3 m3,matrix3 madd){int count=0,temp,k=0;if(m1->data[0][1]!=m3->data[0][0]){printf("不合法矩阵，不能相加");exit(0);}madd->data[0][0]=m1->data[0][0];madd->data[0][1]=m3->data[0][1];// printf("%d %d \n",madd->data[k][0],madd->data[k][1]);while(posi<=m1->size&&posj<=m3->size){k++;// printf("%d %d\n",posi,posj);k=judge(m1,madd,m3,k);//k=temp;}while(posi>=m1->size&&posj<m3->size){madd->data[k][0]=m3->data[0][0];madd->data[k][1]=m3->data[0][1];madd->data[k][2]=m3->data[0][2];k++;// printf(" %d",k);posj++;}while(posj>=m3->size&&posi<m1->size){madd->data[k][0]=m1->data[0][0];madd->data[k][1]=m1->data[0][1];madd->data[k][2]=m1->data[0][2];// printf(" %d",k);k++;posi++;}madd->size=k;madd->data[0][2]=k;}void matrixadd(matrix3 m1,matrix3 m3,matrix3 madd){int count=0,i=1,j=1,temp,k=0;if(m1->data[0][1]!=m3->data[0][0]){printf("不合法矩阵，不能相加");exit(0);}madd->data[0][0]=m1->data[0][0];madd->data[0][1]=m3->data[0][1];printf("%d %d \n",madd->data[k][0],madd->data[k][1]);while(i<=m1->size&&j<=m3->size){// printf("%d %d %d \n",k,madd->data[0][0],madd->data[0][1]); k++;temp=k;// printf(" %d",k);// temp=judge(m1,madd,m3,&i,&j,k);int k10=m1->data[i][0];int k11=m1->data[i][1];int k12=m1->data[i][2];int k30=m3->data[j][0];int k31=m3->data[j][1];int k32=m3->data[j][2];if(k10==k30){if(k11==k31){madd->data[k][0]=k10;madd->data[k][1]=k11;madd->data[k][2]=k12+k32;i++;j++;}else if(k11>k31){madd->data[k][0]=k30;madd->data[k][1]=k31;madd->data[k][2]=k32;j++;}else{madd->data[k][0]=k10;madd->data[k][1]=k11;madd->data[k][2]=k12;i++;}}if(k10>k30){madd->data[k][0]=k30;madd->data[k][1]=k31;madd->data[k][2]=k32;j++;}if(k10<k30){madd->data[k][0]=k10;madd->data[k][1]=k11;madd->data[k][2]=k12;i++;}// printf("%d %d %d\n",madd->data[k][0],madd->data[k][1],madd->data [0][2]);}// printf("---- %d",k);while(i>=m1->size&&j<m3->size){madd->data[k][0]=m3->data[0][0];madd->data[k][1]=m3->data[0][1];madd->data[k][2]=m3->data[0][2];k++;printf(" %d",k);j++;}while(j>=m3->size&&i<m1->size){madd->data[k][0]=m1->data[0][0];madd->data[k][1]=m1->data[0][1];madd->data[k][2]=m1->data[0][2];printf(" %d",k);k++;i++;}madd->size=k;madd->data[0][2]=k;}void print(matrix3 array){//打印稀疏矩阵int i,t,j; t=1;printf("稀疏矩阵为%drows %dcols：\n",array->data[0][0],array->data[0][1]);for(i=1;i<=array->data[0][0];i++){//列优先for(j=1;j<=array->data[0][1];j++){if(i==array->data[t][0]&&j==array->data[t][1]) {printf("%4d",array->data[t][2]);t++;}else printf("%4c",'-');}printf("\n");}}main(){ //此函数实现三元组矩阵相加！FILE *fp1,*fp2;fp1=fopen("trematrix1.txt","r");fp2=fopen("trematrix2.txt","r");matrix3 mat1,mat2,mat3,mtadd;matr mat;mat=(matr)malloc(sizeof(mat));mat1=(matrix3)malloc(sizeof(thrematrix));mat2=(matrix3)malloc(sizeof(thrematrix));mat3=(matrix3)malloc(sizeof(thrematrix));mtadd=(matrix3)malloc(sizeof(thrematrix)); readfile(fp1,mat1);readfile(fp2,mat2);printf("\n矩阵1：\n");// prmatrix(mat1);print(mat1);// printf("\n矩阵2：\n");// prmatrix(mat2);// print(mat2);transpose(mat,mat2,mat3);printf("\n矩阵3：\n");// prmatrix(mat3);print(mat3);matrixadd1(mat1,mat3,mtadd);printf("矩阵1,3相加后结果为：\n");// prmatrix(mtadd);print(mtadd);}。

三元组实现稀疏矩阵加减乘

#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行、列数相等，初始化第三方矩阵的行、列数。

两个稀疏矩阵三元组相加

while(A->data[pa].i==x && B->data[pb].i==x) /*行数相等时*/
{if(A->data[pa].j==B->data[pb].j) /*列数相等时*/
{sum=A->data[pa].v+B->data[pb].v; /*矩阵想加*/
if(sum) /*相加不为零时*/
typedef int DataType; /*用户自定义*/
typedef struct
{ int i,j; DataType v; }Triple;/*定义三元组结构*/
typedef struct
{ Triple data[MaxSize];/*定义可存三元组大小*/
{C-> data[c-> t].i=A-> data[k].i;
C-> data[c-> t].j=A-> data[k].j;
C-> data[c-> t++].v=A-> data[k].v;
k++;
}
if ((A-> data[k].i==B-> data[l].i)&&(A-> data[k].j> B-> data[l].j))
l++;
}
}
while (k <A-> t)//将A中剩余三元组加入C
{C-> data[c-> t].i=A-> data[k].i;
C-> data[c-> t].j=A-> data[k].j;

试验二利用三元组表实现矩阵相加

实验二利用三元组表实现矩阵相加一、预备知识1.稀疏矩阵的三元组表压缩存储结构2.稀疏矩阵的三元组表表示方法下的相加算法二、实验目的1.掌握稀疏矩阵的三元组表存储结构的实现2.实现稀疏矩阵的三元组表表示下的相加算法三、实验内容1.编写程序，实现利用三元组表进行两个稀疏矩阵相加的算法。

要求：（1）随机产生两个可相加的稀疏矩阵（二维）；（2）将产生的稀疏矩阵用两个三元组表的顺序存储结构存储；（3）将两稀疏矩阵相加的结果存储在第三个三元组表中。

2.沿用实验一编写的操作菜单进行上述的操作。

四、实验说明1.三元组表的类型定义#define MAXSIZE 1000//非零元素个数的最大值typedef struct{int row,col;//非零元素的行下标和列下标ElemType e;//非零元素的值} Triple;typedef struct{Triple data[MAXSIZE+1];//非零元素的三元组表，data[0]未用int mu,nu,tu;//矩阵的行数、列数和非零元素个数} TSMatrix;五、注意问题1.首先应输入矩阵的行数和列数,并判别给出的两个矩阵的行、列数对于所要求作的运算是否相匹配。

可设矩阵的行数和列数均不超过20。

2.程序可以对三元组的输入顺序加以限制,例如,按行优先，以便提高计算效率。

3.在用三元组表示稀疏矩阵时,相加或相减所得结果矩阵应该另生成,相加结果矩阵也可用二维数组存放。

4.三元组表是线性表的一种应用，通过它可以更好地理解线性表的存储结构。

同时矩阵又是图的重要的存储方式，所以这个实验对更好地掌握线性表对将来对图的理解都有极大的帮助。

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

在Python中，三元组顺序表表示的稀疏矩阵加法是一个重要的主题。

稀疏矩阵是指大部分元素为零的矩阵，而三元组顺序表是一种压缩稀疏矩阵的方法，它将非零元素的行列坐标及对应的值存储起来，以节省空间和提高运算效率。

在本文中，我们将探讨稀疏矩阵加法在Python中的实现方法，并深入分析其原理和应用。

一、稀疏矩阵及三元组顺序表简介1. 稀疏矩阵稀疏矩阵是指大部分元素为零的矩阵，它在实际问题中的应用非常广泛，如图像处理、网络分析、物理建模等领域。

由于其大部分元素为零，传统的存储和计算方法会浪费大量的空间和时间，因此需要一种高效的表示方法。

2. 三元组顺序表三元组顺序表是一种压缩稀疏矩阵的方法，它将非零元素的行列坐标及对应的值存储起来。

比起普通的二维数组表示方法，三元组顺序表可以更加高效地存储和计算稀疏矩阵，节省空间和提高运算效率。

二、稀疏矩阵加法的原理稀疏矩阵加法是指将两个稀疏矩阵相加，得到一个新的稀疏矩阵。

在三元组顺序表表示的稀疏矩阵中，我们可以通过遍历两个矩阵的非零元素，并按照其行列坐标进行相加，得到新的稀疏矩阵。

三、Python中的实现在Python中，我们可以通过定义稀疏矩阵类和相应的加法运算方法来实现稀疏矩阵的加法。

我们需要定义稀疏矩阵的三元组顺序表表示方法，并实现相应的初始化方法和加法运算方法。

下面是一个简单的Python示例代码：```pythonclass SparseMatrix:def __init__(self, rows, cols, data):self.rows = rowsself.cols = colsself.data = datadef __add__(self, other):result = []i, j = 0, 0while i < len(self.data) and j < len(other.data):if self.data[i][0] == other.data[j][0] and self.data[i][1] == other.data[j][1]:result.append((self.data[i][0], self.data[i][1],self.data[i][2] + other.data[j][2]))i += 1j += 1elif self.data[i][0] < other.data[j][0] or (self.data[i][0] == other.data[j][0] and self.data[i][1] < other.data[j][1]):result.append((self.data[i][0], self.data[i][1],self.data[i][2]))i += 1else:result.append((other.data[j][0], other.data[j][1], other.data[j][2]))j += 1while i < len(self.data):result.append((self.data[i][0], self.data[i][1], self.data[i][2])) i += 1while j < len(other.data):result.append((other.data[j][0], other.data[j][1],other.data[j][2]))j += 1return SparseMatrix(self.rows, self.cols, result)```在上面的示例代码中，我们定义了一个SparseMatrix类，其初始化方法接受稀疏矩阵的行数、列数和三元组顺序表表示的数据。

线性表的插入和删除-栈和队列的算法-利用三元组表实现矩阵相加--实验

内蒙古科技大学信息工程学院计算机系《数据结构与算法》实验报告
add(a,b,c);
nodeprint(c);
return 0;
}
实验过程及结果线性表的顺序存储和删除：线性表的链式存储和删除：
顺序栈：
链队列：
实验三：
实验总结
【实验1】
这次实验了解了线性表的顺序存储结构和线性表的链式存储结构的插入和删除的操作，了解了线性表这两种存储方式的不同以及这两种线性表的优缺点，顺序存储结构的效率较低而链式存储结构的插入和删除效率高一些，操作更容易一些。

【实验2】
这次实验初步掌握了栈和队列的简单应用，学会的创建栈和队列，向栈和队列中传入参数，销毁栈和队列。

【实验3】
这次实验掌握了数组的压缩存储和应用，用三元组实现了矩阵之间的相加
1、每个实验项目填写一份实验报告，电子版命名方式为：学号姓名项目号.doc。

例如：1167111182张三3.doc表示张三做的第3个项目的实验报告。

2、实验报告电子版应该在实验后一周内由学习委员收齐后存放在一个文件夹下，文件夹命
名方式为：软件12-1班3，表示软件12-1班第3个项目的实验报告，压缩。

第一时间发送
给任课教师。

必须以班级为单位上交。