稀疏矩阵的三元组表示（稀疏矩阵的三元组顺序表示方法）

本文目录

• 稀疏矩阵的三元组顺序表示方法
• 一个稀疏矩阵如图所示，写出对应的三元组表示形式
• 稀疏矩阵的三元组表示法
• 对于下列稀疏矩阵写出它的三元组表示法
• 三元组表与稀疏矩阵，怎么转换要求法最好文字表述
• 数据结构（c语言）将稀疏矩阵的三元组表示法以行列（矩阵）形式输出 （不要用二维数组..）
• 带行表的三元组表表示稀疏矩阵
• 稀疏矩阵如何生成相应的三元组顺序表

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

#include《stdio.h》
#include《stdlib.h》
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2
#define MAXSIZE 100
typedef 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 q = 1;
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);
}

一个稀疏矩阵如图所示，写出对应的三元组表示形式

对于稀疏矩阵来说，如果还是用100×100的方式来存储的话，显然是非常浪费的，三元组方式存储数据的策略是只存储非零元素。但是稀疏矩阵中非零元素的分布是没有任何规律的，在这种情况下，表示形式是：

1、存储非零元素

2、同时存储该非零元素所对应的行下标和列下标

3、稀疏矩阵中的每一个非零元素需由一个三元组(i,j,aijaij)唯一确定,稀疏矩阵中的所有非零元素构成三元组线性表，三元组中的i就是行下标，j是列下标，aijaij是对应的元素值。

扩展资料：

稀疏矩阵的压缩存储方法

拿稀疏矩阵中的元素1来说，该元素的位置为第0行，第2列，在用三元组（i ，j ，aij）进行存储时，就是0 2 1，发现在这个三元组的线性表中，每个数据元素都是以三元组的方式组成的。

当确定三元组的存储策略后，要做的就是把这样的三元组存储下来。需要把矩阵中的行数，列数，非零元素个数，矩阵中的数据都保存在data数据域，在data数据域中的每个数据元素都是以三元组形式存储，data域中表示的非零元素通常以行序为主序顺序排列，下标按行有序的存储结构。

算法：以行序方式扫描二维矩阵A，将其非零的元素加入到三元组t。要求为data域以行序为主序顺序排列。

稀疏矩阵的三元组表示法

这很困难吗，我觉得STL的代码更难额，都看不懂....
稀疏矩阵转化为三元组
按列逐个检索，不是零的列出来
三元组的第一元行数，第二元列数，第三元，数据
很简单啊，例子百度百科上就有，代码还是自己写更好

对于下列稀疏矩阵写出它的三元组表示法

三元，即数据所在行，所在列以及数据的值。
((1,1,1),
(1,5,2),
(3,2,-3),
(4,2,-4),
(5,5,-1),
(5,6,15),
(6,4,7))

三元组表与稀疏矩阵，怎么转换要求法最好文字表述

l-》e=(list)malloc((MAXSIZE+1)*sizeof(ElemType));// 这句在VC不能通过编译，因为e是elemtype类型，分配的空间是list类型，不匹配。

三元组，第1列是行号，第2列是列号，第3列是非零元素的值。假设以顺序存储结构来表示三元组表（triple table），则得到稀疏矩阵的一种压缩存储方式，即三元组顺序表，简称三元组表。

扩展资料：

对于在实际问题中出现的大型的稀疏矩阵，若用常规分配方法在计算机中储存，将会产生大量的内存浪费，而且在访问和操作的时候也会造成大量时间上的浪费，为了解决这一问题，从而产生了多种解决方案。

由于其自身的稀疏特性，通过压缩可以大大节省稀疏矩阵的内存代价。具体操作是：将非零元素所在的行、列以及它的值构成一个三元组（i，j，v），然后再按某种规律存储这些三元组，这种方法可以节约存储空间。

参考资料来源：百度百科-三元组

数据结构（c语言）将稀疏矩阵的三元组表示法以行列（矩阵）形式输出 （不要用二维数组..）

#include 《stdio.h》
#define maxsize 12500
#define elemtype int
typedef int status;
typedef struct
{
int i,j;
elemtype e;
}triple;
typedef struct
{
triple data[maxsize+1];
int mu,nu,tu;
}tsmatrix;
tsmatrix creatematrix()
{
tsmatrix M;
int n;
printf(“输入矩阵的行数，列数，个数：\n“);
scanf(“%d%d%d“,&M.mu,&M.nu,&M.tu);
printf(“输入非零元的值（行数、列数和值）：\n“);
for(n=0;n《M.tu;n++)
scanf(“%d%d%d“,&M.data[n].i,&M.data[n].j,&M.data[n].e);
return M;
}
tsmatrix transposesmtrix(tsmatrix M,tsmatrix T)
{
int q,col,p;
T.mu=M.nu; T.nu=M.mu; T.tu=M.tu;
if(T.tu)
{
q=0;
for(col=0;col《M.nu;col++)
for(p=0;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 T;
}
void print(tsmatrix M)
{
int x,y,n,k;
for(x=0;x《M.mu;x++)
{
for(y=0;y《M.nu;y++)
{
k=0;
for(n=0;n《M.tu;n++)
if((M.data[n].i==x)&&(M.data[n].j==y))
{
printf(“%3d“,M.data[n].e);
k=1;
}
if(k==0)
printf(“%3d“,k);
}
printf(“\n“);
}
}
void main()
{
tsmatrix M,T;
M=creatematrix();
printf(“M矩阵为：\n“);
print(M);
T=transposesmtrix(M,T);
printf(“转置后的矩阵为：\n“);
print(T);
}
这是我写的，有矩阵的输出 和矩阵的转置，希望对你有用！

带行表的三元组表表示稀疏矩阵

答案应该选A
带行表的三元组表
　为了方便某些矩阵运算，在按行优先存储的三元组表中，加入一个行表来记录稀疏矩阵中每行的非零元素在三元组表中的起始位置。这就是带行表的三元组表。
（1）类型描述
#define MaxRow l00 //在三元组表定义前加入此最大行定义
typedef struct {
TriTupleNode data[MaxSize]；
int RowTab[MaxRow]；//行表，应保证m≤MaxRow
int m，n，t;
}RTriTupleTable；
(2)带行表的三元组表的操作
① 对于任给行号i(0≤i≤m-1)，能迅速地确定该行的第一个非零元在三元组表中的存储位置为RowTab[i]
② RowTab[i](0≤i≤m-1)表示第i行之前的所有行的非零元数。
③ 第i行上的非零元数目为RowTab[i+1]-RowTab[i](0≤i≤m-2)
④ 最后一行(即第m-l行)的非零元数目为t-RowTab[m-1](t为矩阵的非零元总数)
注意：
　若在行表中令RowTab[m]=t（要求MaxRow》m）会更方便 些，且t可省略。
　带行表的三元组表可改进矩阵的转置算法，具体【参阅其它参考书】。
A选项的行表表示为 02335
B选项的行表表示为 02355
C选项的行表表示为 02235
D选项的行表表示为 02235

稀疏矩阵如何生成相应的三元组顺序表

typedef struct
{
int i,j;
ElemType e;
}Triple;
typedef struct
{
Triple data[MAXSIZE+1];
int mu,nu,tu;
}TSMatrix;
int InitSMatrix(TSMatrix &M)
{
printf(“请输入矩阵的行数：“);
scanf(“%d“,&M.mu);
printf(“列数：“);
scanf(“%d“,&M.nu);
printf(“非零元的个数：“);
scanf(“%d“,&M.tu);
for(int t=1;t《=M.tu;t++) //data不用
{
printf(“第%d个非零元的行号：“,t);
scanf(“%d“,&M.data[t].i);
printf(“第%d个非零元的列号：“,t);
scanf(“%d“,&M.data[t].j);
printf(“第%d个非零元的元素值：“,t);
scanf(“%d“,&M.data[t].e);
}
return OK;
}