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

三元组表示稀疏矩阵的转置(一般算法和快速算法)一、设计要求1.1 问题描述稀疏矩阵是指那些多数元素为零的矩阵。
利用稀疏特点进行存储和计算可以大大节省存储空间,提高计算效率。
求一个稀疏矩阵A的转置矩阵B。
1.2需求分析(1)以“带行逻辑链接信息”的三元组顺序表表示稀疏矩阵,实现稀疏矩阵的转置运算。
(2)稀疏矩阵的输入形式采用三元组表示,运算结果则以通常的阵列形式列出。
(3)首先提示用户输入矩阵的行数、列数、非零元个数,再采用三元组表示方法输入矩阵,然后进行转置运算,该系统可以采用两种方法,一种为一般算法,另一种为快速转置算法。
(4)程序需要给出菜单项,用户按照菜单提示进行相应的操作。
二、概要设计2.1存储结构设计采用“带行逻辑链接信息”的三元组顺序表表示矩阵的存储结构。
三元组定义为:typedef struct{int i; //非零元的行下标int j; //非零元的列下标 ElemType e; //非零元素值}Triple; 矩阵定义为: Typedef struct{Triple data[MAXSIZE+1]; //非零元三元组表int rpos[MAXRC+1]; //各行第一个非零元的位置表 int mu,nu,tu; //矩阵的行数、列数和非零元个数 }RLSMatrix;例如有矩阵A,它与其三元组表的对应关系如图2.2 系统功能设计本系统通过菜单提示用户首先选择稀疏矩阵转置方法,然后提示用户采用三元组表示法输入数据创建一个稀疏矩阵,再进行矩阵的转置操作,并以通常的阵列形式输出结果。
主要实现以下功能。
(1)创建稀疏矩阵。
采用带行逻辑连接信息的三元组表表示法,提示用户输入矩阵的行数、列数、非零元个数以及各非零元所在的行、列、值。
(2)矩阵转置。
<1>采用一般算法进行矩阵的转置操作,再以阵列形式输出转置矩阵B。
<2>采用快速转置的方法完成此操作,并以阵列形式输出转置矩阵B。
稀疏矩阵的三元组顺序表存储表示及其转置算法

稀疏矩阵的三元组顺序表存储表示及其转置算法目录1. 引言1.1 背景和意义1.2 结构概述1.3 目的2. 稀疏矩阵的三元组顺序表存储表示2.1 稀疏矩阵的定义与特点2.2 三元组顺序表的数据结构和实现方式2.3 存储表示的优缺点分析3. 稀疏矩阵转置算法3.1 转置操作的意义与应用场景3.2 基于三元组顺序表的转置算法设计思路3.3 转置算法的具体实现步骤与复杂度分析4. 实验与结果分析4.1 实验设置和数据样本介绍4.2 转置算法在不同稀疏矩阵上的性能评估和结果比较4.3 分析结果及启示与讨论5. 结论与展望5.1 结论总结5.2 存在问题及后续工作展望1. 引言1.1 背景和意义稀疏矩阵是一种在实际问题中经常遇到的特殊矩阵结构,其绝大部分元素为零。
与稠密矩阵相比,稀疏矩阵的存储和计算效率更高。
稀疏矩阵可以应用于图像处理、网络分析、线性代数等领域。
三元组顺序表是一种存储稀疏矩阵的数据结构,通过记录非零元素的行索引、列索引和数值,有效地减少了存储空间。
同时,三元组顺序表也提供了便捷的转置操作方式。
因此,深入掌握稀疏矩阵的三元组顺序表存储表示及其转置算法对于提高稀疏矩阵相关问题的解决效率具有重要意义。
1.2 结构概述本文将从两个方面进行论述。
首先,介绍稀疏矩阵的定义与特点,以及三元组顺序表在存储表示中所采用的数据结构和实现方式。
其次,详细描述了基于三元组顺序表的稀疏矩阵转置算法的设计思路、具体实现步骤和复杂度分析。
1.3 目的本文旨在探究稀疏矩阵的三元组顺序表存储表示及其转置算法,在理论层面上深入分析其原理和优劣,并在实验中验证其性能表现。
通过本文的研究,我们希望能够提供一种高效、灵活且易于实现的方法来处理稀疏矩阵,并为进一步的相关应用提供有价值的启示和参考。
2. 稀疏矩阵的三元组顺序表存储表示2.1 稀疏矩阵的定义与特点稀疏矩阵是指在一个二维矩阵中,大部分元素都为0的情况下,只有少数非零元素的情况。
矩阵转置

下面就是(算式1)式中矩阵M的(5行6列共有)8个非零元素的三元组表示:
{ (1,1, 8), (1,3, 9) , (2,2,2) , (3,4,3) , (3,6,7) , (4,1,6) , (4,3,4) , (5,4,5)}
若以某种方式(以行为主或以列为主的顺序)将8个三元组排列起来,再加上一个表示矩阵M的行数,列数及非零元素的个数的特殊的三元组(5,6,8),则所形成的表就能唯一地确定稀疏矩阵。
5.快速转置算法程序:
void fastran(Spmatrix a,Spmatrix *b)
{ int k,p,q,col;
int num[10],pot[10];
b->m=a.n; b->n=a.m; b->t=a.t;
if (a.t!=0)
普通算法分析:按b.data中三元组的次序进行转置。也就是说,按照矩阵M的列序进行转置。显然,为了找到M中的每一列的所有的非零元素,需要对a.data从第1行起整个扫描一遍。由于a.data是以M的行序来存放每一个非零元素的,因此,这样得到的顺序恰好是b.data应有的顺序。其具体算法描述如下:
矩阵的转置运算是变换元素的位置,把位于(i, j)的元素换到(j, i)位置上。也就是说,把元素的行和列对换。所以一个m×n的矩阵M,它的转置矩阵是一个n×m的矩阵,且N[i,j]=M[j,i],其中,1≤i≤n,1≤j≤m。例如, (算式1)中的矩阵N就是矩阵M的转置矩阵,矩阵N也是一个稀疏矩阵,其非零元素的排列情况如表-1(b)所示。求矩阵M的转置矩阵N,实际上就是由表-1(a)求表-1(b)。
这比直接用二维数组表示矩阵的转置算法的时间量级O(m*n)要差。不难看出,此算法之所以耗费时间,问题在于其每形成转置矩阵的一行,都必须对a.data从头到尾扫描一遍。能否对a.data只扫描一次,又不引起元素的移动就能得到要求的b->data呢?为此,我们可使用另一种快速方法。
数据结构稀疏矩阵转置,加法

数据结构稀疏矩阵转置,加法《数据结构》实验报告◎实验题⽬:稀疏矩阵的转置、加法(⾏逻辑链接表)◎实验⽬的:学习使⽤三元组顺序表表⽰稀疏矩阵,并进⾏简单的运算◎实验内容:以三元组表表⽰稀疏矩阵,并进⾏稀疏矩阵的转置和加法运算。
⼀、需求分析该程序⽬的是为了⽤三元组表实现稀疏矩阵的转置和加法运算。
1、输⼊时都是以三元组表的形式输⼊;2、输出时包含两种输出形式:运算后得到的三元组表和运算后得到的矩阵;3、测试数据:(1)转置运算时输⼊三元组表:1 2 121 3 93 1 -33 6 144 3 245 2 186 1 156 4 -7得到转置后的三元组表:1 3 -31 6 152 1 122 5 183 1 93 4 244 6 -76 3 14(2)进⾏加法运算时先输⼊矩阵A(以三元组表形式):1 1 12 2 22 3 43 1 -4输⼊矩阵B(以三元组表形式):1 3 -22 3 -53 1 83 2 -6A与B的和矩阵以矩阵形式输出为:1 0 -20 2 -14 -6 0(⼆) 概要设计为了实现上述操作⾸先要定义三元组表,稀疏矩阵:typedef struct{int i,j;int e;}Triple;//三元组typedef struct{Triple data[MAXSIZE+1];int mu,nu,tu;}Matrix;//稀疏矩阵1.基本操作void CreatMatrix(Matrix *m)操作结果:创建⼀个稀疏矩阵。
void PrintMatrix(Matrix m)初始条件:矩阵m已存在。
操作结果:将矩阵m以矩阵的形式输出。
void FastTransposeMatrix(Matrix a,Matrix *b)初始条件:稀疏矩阵a已存在;操作结果:将矩阵a进⾏快速转置后存⼊b中。
void AddMatrix(Matrix a,Matrix b,Matrix *c)初始条件:稀疏矩阵a和b都已存在;操作结果:将矩阵a和b的和矩阵存⼊c中。
稀疏矩阵三元组实现矩阵转置算法实验报告

稀疏矩阵三元组实现矩阵转置算法实验报告实验三稀疏矩阵的三元组表示实现矩阵转置算法学院专业班学号姓名一.实习目的1.掌握稀疏矩阵的三元组顺序表存储表示;2.掌握稀疏矩阵三元组表示的传统转置算法的实现;3.掌握稀疏矩阵三元组表示的快速转置算法的实现;二.实习内容1.稀疏矩阵的按三元组形式输入,即按行序输入非零元的行号、列号、值,实现传统转置算法,输出按通常的阵列形式输出。
2.稀疏矩阵的按三元组形式输入,即按行序输入非零元的行号、列号、值,实现快速转置算法,输出按通常的阵列形式输出。
三.实验步骤1.三元组的定义#define MAX_SIZE 100 // 非零元个数的最大值struct Triple{int i,j; // 行下标,列下标ElemType e; // 非零元素值};struct TSMatrix{struct Triple data[MAX_SIZE+1]; // 非零元三元组表,data[0]未用int mu,nu,tu; // 矩阵的行数、列数和非零元个数};2.创建稀疏矩阵M (按三元组形式输入,即按行序输入非零元的行号、列号、值)3. 编写三元组传统转置函数。
4. 编写三元组快速转置函数。
4. .主函数(1)程序代码#include "stdio.h"#include "stdlib.h"#define MAX_SIZE 100 // 非零元个数的最大值typedef int ElemType;struct Triple{int i,j; // 行下标,列下标ElemType e; // 非零元素值};struct TSMatrix{struct Triple data[MAX_SIZE+1]; // 非零元三元组表,data[0]未用int mu,nu,tu; // 矩阵的行数、列数和非零元个数};int CreateSMatrix(TSMatrix &M){ // 创建稀疏矩阵Mint i,m,n;ElemType e;int k;printf("请输入矩阵的行数,列数,非零元素数:");scanf("%d,%d,%d",&M.mu,&M.nu,&M.tu);if(M.tu>MAX_SIZE)return -1;M.data[0].i=0; // 为以下比较顺序做准备for(i=1;i<=M.tu;i++){do{printf("请按行序顺序输入第%d个非零元素所在的行(1~%d),列(1~%d),元素值:",i,M.mu,M.nu);scanf("%d,%d,%d",&m,&n,&e);//输入非零元的行号、列号、元素值k=0;if(m<1||m>M.mu||n<1||n>M.nu)// 行或列超出范围k=1;if(m<M.data[i-1].i||m==M.data[i-1].i&&n<=M.d ata[i-1].j) // 行或列的顺序有错k=1;}while(k);M.data[i].i =m; // 将m,n,e 填入MM.data[i].j =n;M.data[i].e =e;}return 1;}void PrintSMatrix(TSMatrix M){ // 按矩阵形式输出Mint i,j,k=1;Triple *p=M.data;p++; // p指向第1个非零元素for(i=1;i<=M.mu;i++){for(j=1;j<=M.nu;j++)if(k<=M.tu&&p->i==i&&p->j==j)// p指向非零元,且p所指元素为当前处理元素{printf("%3d",p->e); // 输出p所指元素的值p++; // p指向下一个元素k++; // 计数器+1}else // p所指元素不是当前处理元素printf("%3d",0); // 输出0printf("\n");}}void TransposeSMatrix(TSMatrix M,TSMatrix &T){ // 求稀疏矩阵M的转置矩阵T。
三元组快速转置算法

三元组快速转置算法
三元组快速转置算法是一种用于将稀疏矩阵的三元组表示转置的算法。
稀疏矩阵是指大部分元素为0的矩阵,而三元组表示是一种常用的稀疏矩阵存储方式。
三元组表示将稀疏矩阵中非零元素的位置和对应的值存储起来,通常由三个数组来表示:行索引数组(row),列索引数组(col)和值数组(val)。
每个非零元素都有一个对应的行索引、列索引和值。
快速转置算法的基本思想是通过遍历三元组表示中的元素,将其按照列索引重新排序,并计算每个列索引在转置后的矩阵中的起始位置。
然后再遍历三元组表示,将每个元素插入到转置后相应的位置。
这样就完成了矩阵转置的过程。
具体实现快速转置算法的步骤如下:
1. 统计每个列索引出现的次数,得到每个列索引在转置后的矩阵中的起始位置。
2. 计算每个列索引在转置后的矩阵中的终止位置。
3. 根据起始位置和终止位置,确定每个非零元素在转置后的矩阵中的位置。
4. 将每个非零元素插入到转置后的矩阵中相应的位置。
快速转置算法的时间复杂度取决于稀疏矩阵中非零元素的个数和矩阵的维度。
相比于其他转置算法,快速转置算法在处理大规模稀疏矩阵时具有较高的效率。
需要注意的是,三元组表示和快速转置算法都是用于稀疏矩阵的
存储和操作,对于密集矩阵则没有优势。
数据结构25:矩阵转置算法(三元组顺序表)

数据结构25:矩阵转置算法(三元组顺序表)矩阵的转置实际上就是将数据元素的⾏标和列标互换,即 T(i,j) = M(j,i) 。
例如:图1 矩阵的转置相应地,三元组表转变为:图2 三元组表矩阵的转置,经历了三个步骤:矩阵的⾏数 n 和列数 m 的值交换;将三元组中的i和j调换;转换之后的表同样按照⾏序(置换前的列序)为主序,进⾏排序;实现三元组的转换,重点在第三步,实现算法有两种。
普通算法普通算法的实现过程为:1. 将矩阵的⾏数和列数进⾏调换;2. 遍历表 a 的 j 列(查找 j 的值,从 1 ⼀直到未转置之前的矩阵的列数 m ),遍历的过程,就可以⾃动存储为表 b 的形式。
因为在表 a 中 i 列的数值是从⼩到⼤的,在根据 j 列由上到下的遍历时, i 列同样也是有序的。
实现代码:TSMatrix transposeMatrix(TSMatrix M, TSMatrix T){ //⾏和列置换 T.m = M.n; T.n = M.m; T.num = M.num; if (T.num) { int q = 0; //依次遍历M矩阵的列(从1开始),的遍历的过程中将⾏标和列标置换,得到置换后的三元表T for (int col=1; col<=M.m; col++) { for (int p=0; p<M.num; 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].data = M.data[p].data; q++; } } } } return T;}此算法的时间复杂度关键在于嵌套的两个 for 循环,时间复杂度为O(m*num),和矩阵的列数以及⾮ 0 元素的个数的乘积成正⽐,如果稀疏矩阵的⾮ 0 元素很多的情况,使⽤这个算法,虽然⼀定程度上节省了空间,但是时间复杂度会很⾼。
矩阵转置及相加实验报告

一、实验内容和要求1、稀疏矩阵A,B均采用三元组表示,验证实现矩阵A快速转置算法,设计并验证A,B相加得到矩阵C的算法。
(1)从键盘输入矩阵的行数和列数,随机生成稀疏矩阵。
(2)设计算法将随机生成的稀疏矩阵转换成三元组顺序表示形式存储。
(3)设计算法将快速转置得到的与相加得到的三元组顺序表分别转换成矩阵形式。
(4)输出随机生成的稀疏矩阵A,B及其三元组顺序表、快速转置得到的与相加得到的三元组顺序表及其矩阵形式。
二、实验过程及结果一、需求分析1、将随机生成的数定义为int型(为方便起见设定范围为-20至20(不含0),可修改),三元组存储的元素分别为非零元的行下标、列下标及该位置的元素值,零元不进行存储。
实际上在生成稀疏矩阵时是随机选取一些位置生成非零元然后存入三元组中。
2、从键盘输入矩阵的行数和列数后应能输出三元组顺序表及相应矩阵(按行和列排列形式输出)。
3、程序能实现的功能包括:①随机产生稀疏矩阵;②输出阵列形式的矩阵;③输出三元组顺序表;④将矩阵快速转置;⑤将两个稀疏矩阵相加生成新的矩阵。
二、概要设计1、稀疏矩阵的抽象数据类型定义:ADT TSMatrix{数据对象:D={ aij|i=1,2,…,m,j=1,2,…,n;Ai,j∈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}基本操作:CreateTSMatrix(&M)操作结果:创建矩阵MPrintTSMatrix(M)初始条件:矩阵M已存在操作结果:输出矩阵M中三元组形式的非零元素PrintTSMatrix1(M)初始条件:矩阵M已存在操作结果:以阵列形式输出矩阵UnZore(M, row, col)初始条件:矩阵M已存在操作结果:若位置(row,col)处存在非零元素,则返回该元素存储在矩阵中的序号TSMatrix_Add(M, N,&Q)初始条件:矩阵M,N已存在操作结果:将矩阵M,N相加得到Q并返回矩阵QFastTransposeSMatrix(M,&N)初始条件:矩阵M已存在操作结果:将矩阵M快速转置得到转置矩阵N并返回}ADT TSMatrix;⒊本程序模块结构⑴主函数模块void main(){初始化迷矩阵;创建矩阵并输出;将矩阵转置并输出;将矩阵相加并输出结果;}三、详细设计1、基本数据类型操作⑴typedef int ElemType;typedef struct{int i,j;ElemType e;}Triple;//数据类型三元组typedef struct{Triple data[maxsize+1];//矩阵大小int mu,nu,tu; //}TSMatrix;//矩阵抽象数据类型2、参数设置:#define maxsize 10000//----------基本操作的算法描述--------------------Status CreateTSMatrix(TSMatrix *M){//创建一个随机矩阵(data[0]未用)srand((int)time(NULL));printf("Please Input The Lines And Columns Of The Matrix:\n");printf("...(矩阵的期望规格大于4*5(或5*4))...\n");scanf(M->mu,M->nu);for(m=0;m<M->mu;m++){for(n=0;n<M->nu;n++){k[m][n]=rand()%20;if(k[m][n]==0){if(rand()%2)M->data[p].e=rand()%20+1;elseM->data[p].e=rand()%20-20;M->data[p].i=m+1;M->data[p].j=n+1;p++;}}}M->tu=p-1; //p从1开始,非零元个数刚好等于p-1return OK;}void PrintTSMatrix(TSMatrix M){//输出矩阵的三元组顺序表if(M.tu==0)printf("无非零元!\n");else{printf("该矩阵的行数为%d、列数为%d、非零元素个数为%d.\n非零元的坐标及值:\n\n",M.mu,M.nu,M.tu);printf(" 行列元素值\n");for(i=1;i<=M.tu;i++){printf("%4d%4d%6d\n",M.data[i].i,M.data[i].j,M.data[i].e);}printf("\n");}}void PrintTSMatrix1(TSMatrix M){//输出矩阵的阵列形式printf("阵列形式为:\n");for(i=1;i<=M.mu;i++){for(j=1;j<=M.nu;j++)if (k<M.tu&&p->i==i&&p->j==j){printf("%4d",p->e); //data[0]未用,p从data[1]开始p++;k++;}elseprintf("%4d",0);printf("\n");}printf("\n");}int UnZore(TSMatrix M,int row,int col){while(order<=M.tu){if(M.data[order].i==row&&M.data[order].j==col)//order从1开始return order;order++;}return 0;}Status TSMatrix_Add(TSMatrix M,TSMatrix N,TSMatrix *Q){//矩阵相加得到新的矩阵,order从1开始if(M.mu==N.mu&&M.nu==N.nu){for(row=1;row<=M.mu;row++){for(col=1;col<=M.nu;col++){order1=UnZore(M,row,col);order2=UnZore(N,row,col);if(order1&&order2){Q->data[order].i=row;Q->data[order].j=col;Q->data[order].e=M.data[order1].e+N.data[order2].e;order++;}else if(order1&&(!order2)){Q->data[order].e=M.data[order1].e;Q->data[order].i=M.data[order1].i;Q->data[order].j=M.data[order1].j;order++;}else if((!order1)&&order2){Q->data[order].e=N.data[order2].e;Q->data[order].i=N.data[order2].i;Q->data[order].j=N.data[order2].j;order++;}}}Q->mu=M.mu;Q->nu=M.nu;Q->tu=order-1;return OK;}else{printf("\n不是同型矩阵不能进行相加!\n");return ERROR;}}Status FastTransposeSMatrix(TSMatrix M,TSMatrix *N){//采用三元组顺序表存储表示,求稀疏矩阵M的转置矩阵NN->mu=M.nu;N->nu=M.mu;N->tu=M.tu;if(N->tu){for(i=1;i<=M.nu;++i)num[i]=0;for(t=1;t<=M.tu;++t)++num[M.data[t].j];//求M中每一列非零元个数 cpot[1]=1;//求第col列中第一个元素在b.data中的序号for(i=2;i<=M.nu;++i)cpot[i]=cpot[i-1]+num[i-1];for(p=1;p<=M.tu;++p){i=M.data[p].j;q=cpot[i];N->data[q].i=M.data[p].j;N->data[q].j=M.data[p].i;N->data[q].e=M.data[p].e;++cpot[i];}}return OK;}⑶主函数算法:void main(){TSMatrix A,A1,B,C;printf("矩阵A:\n");CreateTSMatrix(&A);PrintTSMatrix(A);PrintTSMatrix1(A);printf("由矩阵A转置得矩阵A1...\n");FastTransposeSMatrix(A,&A1);PrintTSMatrix(A1);PrintTSMatrix1(A1);printf("矩阵B:\n");CreateTSMatrix(&B);PrintTSMatrix(B);PrintTSMatrix1(B);printf("矩阵A加矩阵B得到矩阵C...\n");if(TSMatrix_Add(A,B,&C)){PrintTSMatrix(C);PrintTSMatrix1(C);}}四、调试分析1、三元组顺序表的输出顺序应该是先按行排序再按列排序,即行主序,依次输出。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
三元组顺序表实现矩阵的转置:
/*--------------------------------------------------------------
----------------用三元组顺序表实现对稀疏矩阵的转置-----------------
------------------------编译环境:VS 2013------------------------
--------------------------------------------------------------*/
#define_CRT_SECURE_NO_WARNINGS//用于取消VS 2013对printf、scanf等函数的警告#include<stdio.h>
#include<stdlib.h>
#define MAXSIZE 100
typedef int ElemType;
typedef struct
{
int i;
int j;
ElemType e;
}tupletype;
typedef struct
{
int rownum;
int colnum;
int nznum;
tupletype data[MAXSIZE];
}table;
void creatable(table *M); //用户输入,创建一个三元组表
void trans(table *M, table *T); //转置
void show(table *M); //以矩阵形式输出三元组表
int main()
{
table M, T;
creatable(&M);
system("cls");
puts("矩阵M:");
show(&M);
trans(&M, &T);
puts("矩阵M的转置矩阵T:");
show(&T);
return 0;
}
void creatable(table *M)
{
int row, col, i, j, nz;
ElemType e;
printf("请输入矩阵M的行、列、非零元素个数(中间用逗号隔开):");
scanf("%d,%d,%d", &row, &col, &nz);
M->rownum = row;
M->colnum = col;
M->nznum = 0;
while (M->nznum < nz)
{
printf("请输入依次输入矩阵M中非零元素的行标(1~%d)、列标(1~%d)和元素值:", row, col);
scanf("%d,%d,%d", &i, &j, &e);
if (e != 0)
{
M->data[M->nznum].i = i - 1;
M->data[M->nznum].j = j - 1;
M->data[M->nznum].e = e;
M->nznum++;
}
}
}
void trans(table *M, table *T)
{
int col, b, q = 0;
T->rownum = M->colnum;
T->colnum = M->rownum;
T->nznum = M->nznum;
if (T->nznum != 0)
{
for (col = 0; col < M->colnum; col++)
{
for (b = 0; b < M->nznum; b++)
{
if (M->data[b].j == col)
{
T->data[q].i = M->data[b].j;
T->data[q].j = M->data[b].i;
T->data[q].e = M->data[b].e;
q++;
}
}
}
}
}
void show(table *M)
{
int i, j, k, e;
for (i = 0; i < M->rownum; i++)
{
for (j = 0; j < M->colnum; j++)
{
e = 0;
for (k = 0; k < M->nznum; k++)
{
if (i == M->data[k].i && j == M->data[k].j)
{
e = M->data[k].e;
break;
}
}
printf("%4d", e);
}
printf("\n\n");
}
}
程序运行结果图:。