正文
c语言稀疏矩阵函数 c语言数据结构稀疏矩阵
提示：扫一扫查出行【扫一扫了解最新限行尾号】
复制提示
C语言 我用一个函数构造了稀疏矩阵，可是到了函数外就无法使用，这是为什么！？
问题出在c语言稀疏矩阵函数了“M=(ElemType**)malloc(sizeof(ElemType*)*m);”
你在一个函数内部开辟了空间c语言稀疏矩阵函数，退出函数时就释放掉了，所以就挂了呗。。。。。
程序bug，不能这么用c语言稀疏矩阵函数的，你这么开辟的空间就废掉了，，，，
相关问答
Q1: c语言稀疏矩阵的加法问题
#include stdio.h
#include malloc.h
#define MAX 100
struct matnode //十字链表结点c语言稀疏矩阵函数的定义
{
int row,col;
struct matnode *right,*down;
union {
int val;//表结点使用V域
struct matnode *next;//表头结点使用next域
}tag;
};
struct matnode *createmat(struct matnode *hmone[MAX])
{
int m,n,t,s,i,r,c,v;
// struct matnode *l,*p,*q;
struct matnode *h[100],*l,*p,*q; //h[]是十字链表每行c语言稀疏矩阵函数的表头指针数组
printf("行数m,列数n,非零元素个数t:");
//scanf("%d,%d,%d",m,n,t); //输入行、列数c语言稀疏矩阵函数，非零元素个数
scanf("%d,%d,%d",m,n,t);//输入行、列数c语言稀疏矩阵函数，非零元素个数
l=(struct matnode *)malloc(sizeof(struct matnode));
h[0]=l;//h[]是指针数组c语言稀疏矩阵函数，分别指向头节点和行、列表头结点
l-row=m; //建立十字链表头结点*l
Q2: 稀疏矩阵的转置运算用C语言
#includestring.h
#includectype.h
#includemalloc.h // malloc()等
#includelimits.h // INT_MAX等
#includestdio.h // EOF(=^Z或F6),NULL
#includestdlib.h // atoi()
#includeio.h // eof()
#includemath.h // floor(),ceil(),abs()
#includeprocess.h // exit()
#includeiostream.h // cout,cin
// 函数结果状态代码
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
// #define OVERFLOW -2 因为在math.h中已定义OVERFLOWc语言稀疏矩阵函数的值为3,故去掉此行
typedef int Status; // Status是函数c语言稀疏矩阵函数的类型,其值是函数结果状态代码，如OK等
typedef int Boolean; // Boolean是布尔类型,其值是TRUE或FALSE
typedef int ElemType;
// c5-2.h 稀疏矩阵的三元组顺序表存储表示
#define MAXSIZE 100 // 非零元个数的最大值
struct Triple
{
int i,j; // 行下标,列下标
ElemType e; // 非零元素值
};
struct TSMatrix
{
Triple data[MAXSIZE+1]; // 非零元三元组表,data[0]未用
int mu,nu,tu; // 矩阵的行数、列数和非零元个数
};
// bo5-2.cpp 三元组稀疏矩阵的基本操作,包括算法5.1(9个)
Status CreateSMatrix(TSMatrix M)
{ // 创建稀疏矩阵M
int i,m,n;
ElemType e;
Status k;
printf("请输入矩阵的行数,列数,非零元素数：");
scanf("%d,%d,%d",M.mu,M.nu,M.tu);
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(m1||mM.mu||n1||nM.nu) // 行或列超出范围
k=1;
if(mM.data[i-1].i||m==M.data[i-1].in=M.data[i-1].j) // 行或列的顺序有错
k=1;
}while(k);
M.data[i].i=m;
M.data[i].j=n;
M.data[i].e=e;
}
return OK;
}
void DestroySMatrix(TSMatrix M)
{ // 销毁稀疏矩阵M
M.mu=0;
M.nu=0;
M.tu=0;
}
void PrintSMatrix(TSMatrix M)
{ // 输出稀疏矩阵M
int i;
printf("%d行%d列%d个非零元素。\n",M.mu,M.nu,M.tu);
printf("行 列 元素值\n");
for(i=1;i=M.tu;i++)
printf("%2d%4d%8d\n",M.data[i].i,M.data[i].j,M.data[i].e);
}
Status CopySMatrix(TSMatrix M,TSMatrix T)
{ // 由稀疏矩阵M复制得到T
T=M;
return OK;
}
int comp(int c1,int c2) // 另加
{ // AddSMatrix函数要用到
int i;
if(c1c2)
i=1;
else if(c1==c2)
i=0;
else
i=-1;
return i;
}
Status AddSMatrix(TSMatrix M,TSMatrix N,TSMatrix Q)
{ // 求稀疏矩阵的和Q=M+N
Triple *Mp,*Me,*Np,*Ne,*Qh,*Qe;
if(M.mu!=N.mu)
return ERROR;
if(M.nu!=N.nu)
return ERROR;
Q.mu=M.mu;
Q.nu=M.nu;
Mp=M.data[1]; // Mp的初值指向矩阵M的非零元素首地址
Np=N.data[1]; // Np的初值指向矩阵N的非零元素首地址
Me=M.data[M.tu]; // Me指向矩阵M的非零元素尾地址
Ne=N.data[N.tu]; // Ne指向矩阵N的非零元素尾地址
Qh=Qe=Q.data; // Qh、Qe的初值指向矩阵Q的非零元素首地址的前一地址
while(Mp=MeNp=Ne)
{
Qe++;
switch(comp(Mp-i,Np-i))
{
case 1: *Qe=*Mp;
Mp++;
break;
case 0: switch(comp(Mp-j,Np-j)) // M、N矩阵当前非零元素的行相等,继续比较列
{
case 1: *Qe=*Mp;
Mp++;
break;
case 0: *Qe=*Mp;
Qe-e+=Np-e;
if(!Qe-e) // 元素值为0，不存入压缩矩阵
Qe--;
Mp++;
Np++;
break;
case -1: *Qe=*Np;
Np++;
}
break;
case -1: *Qe=*Np;
Np++;
}
}
if(MpMe) // 矩阵M的元素全部处理完毕
while(Np=Ne)
{
Qe++;
*Qe=*Np;
Np++;
}
if(NpNe) // 矩阵N的元素全部处理完毕
while(Mp=Me)
{
Qe++;
*Qe=*Mp;
Mp++;
}
Q.tu=Qe-Qh; // 矩阵Q的非零元素个数
return OK;
}
Status SubtSMatrix(TSMatrix M,TSMatrix N,TSMatrix Q)
{ // 求稀疏矩阵的差Q=M-N
int i;
for(i=1;i=N.tu;i++)
N.data[i].e*=-1;
AddSMatrix(M,N,Q);
return OK;
}
Status MultSMatrix(TSMatrix M,TSMatrix N,TSMatrix Q)
{ // 求稀疏矩阵的乘积Q=M*N
int i,j,h=M.mu,l=N.nu,Qn=0;
// h,l分别为矩阵Q的行、列值,Qn为矩阵Q的非零元素个数，初值为0
ElemType *Qe;
if(M.nu!=N.mu)
return ERROR;
Q.mu=M.mu;
Q.nu=N.nu;
Qe=(ElemType *)malloc(h*l*sizeof(ElemType)); // Qe为矩阵Q的临时数组
// 矩阵Q的第i行j列的元素值存于*(Qe+(i-1)*l+j-1)中，初值为0
for(i=0;ih*l;i++)
*(Qe+i)=0; // 赋初值0
for(i=1;i=M.tu;i++) // 矩阵元素相乘，结果累加到Qe
for(j=1;j=N.tu;j++)
if(M.data[i].j==N.data[j].i)
*(Qe+(M.data[i].i-1)*l+N.data[j].j-1)+=M.data[i].e*N.data[j].e;
for(i=1;i=M.mu;i++)
for(j=1;j=N.nu;j++)
if(*(Qe+(i-1)*l+j-1)!=0)
{
Qn++;
Q.data[Qn].e=*(Qe+(i-1)*l+j-1);
Q.data[Qn].i=i;
Q.data[Qn].j=j;
}
free(Qe);
Q.tu=Qn;
return OK;
}
Status TransposeSMatrix(TSMatrix M,TSMatrix T)
{ // 求稀疏矩阵M的转置矩阵T。算法5.1
int p,q,col;
T.mu=M.nu;
T.nu=M.mu;
T.tu=M.tu;
if(T.tu)
{
q=1;
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;
}
Status FastTransposeSMatrix(TSMatrix M,TSMatrix T)
{ // 快速求稀疏矩阵M的转置矩阵T。算法5.2
int p,q,t,col,*num,*cpot;
num=(int *)malloc((M.nu+1)*sizeof(int)); // 生成数组（[0]不用）
cpot=(int *)malloc((M.nu+1)*sizeof(int)); // 生成数组（[0]不用）
T.mu=M.nu;
T.nu=M.mu;
T.tu=M.tu;
if(T.tu)
{
for(col=1;col=M.nu;++col)
num[col]=0; // 设初值
for(t=1;t=M.tu;++t) // 求M中每一列含非零元素个数
++num[M.data[t].j];
cpot[1]=1;
for(col=2;col=M.nu;++col) // 求第col列中第一个非零元在T.data中的序号
cpot[col]=cpot[col-1]+num[col-1];
for(p=1;p=M.tu;++p)
{
col=M.data[p].j;
q=cpot[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;
++cpot[col];
}
}
free(num);
free(cpot);
return OK;
}
void main()
{
TSMatrix A,B;
printf("创建矩阵A: ");
CreateSMatrix(A);
PrintSMatrix(A);
FastTransposeSMatrix(A,B);
printf("矩阵B(A的快速转置): ");
PrintSMatrix(B);
DestroySMatrix(A);
DestroySMatrix(B);
}
稀疏矩阵三元组转置，c语言稀疏矩阵函数你参考下
Q3: 帮帮忙!!!如何用C语言实现稀疏矩阵的转置?
（C语言）稀疏矩阵的快速转置算法/*矩阵的快速转置*/
#include stdio.h
#include stdlib.h
#include process.h
#define MAXSIZE 200 /*矩阵中最大非零元的个数*/
typedef struct triple
{
int i; /*行标,本程序中从1开始的*/
int j; /*列标，本程序中从1开始的*/
int e; /*非零元*/
}Triple; /*三元组定义*/
typedef struct tabletype
{
int mu; /*矩阵的行数*/
int nu; /*列数*/
int tu; /*非零元个数*/
Triple data[MAXSIZE]; /*非零元的三元组表,本程序中是从data[1]开始使用的*/
}Tabletype; /*三元组线性表*/
/*以下为函数声明，注意和书本上的参数类型不同，我用的形参全为指针*/
void CreatSMatrix(Tabletype *); /*生成矩阵*/
void DestroySMatrix(Tabletype *); /*销毁矩阵*/
void out_matrix(Tabletype *); /*打印 矩阵*/
int FastTransposeSMatrix(Tabletype *,Tabletype *); /*快速转置算法*/
int main( void ) /*主函数*/
{
char ch;
Tabletype a = {0,0,0,{0,0,0}}; /*初始化为0，便于输入数据时的无效检测*/
Tabletype b; /*声明矩阵b*/
while(1)
{
printf(" @@@@@@@@@@@@@@本程序的功能是实现稀疏矩阵的快速转置@@@@@@@@@@@@@@@\n");
printf(" @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n");
CreatSMatrix(a);
printf("The source Matrix:\n");
out_matrix(a);
if(FastTransposeSMatrix(a,b)) /*若a不为零矩阵则转置a，存入b中*/
{ printf("After TransposeSMatrix: \n");
out_matrix(b);
}
else
{
printf("The matrix is zeros:\n");
out_matrix(a);
}
/*以下为程序控制*/
printf("Input 'q' to quit and 'c' run again:");
do{
if((ch = getchar()) == 'q' || ch == 'Q')
{
DestroySMatrix(a);
DestroySMatrix(b);
exit(0);
}
}while((ch!='C') (ch!='c'));
system("cls");
}
return 1;
}
void CreatSMatrix(Tabletype *a)
{
int i;
printf("请输入矩阵的行数、列数和非零元个数，用空格间隔:");
scanf("%d%d%d",(a-mu),(a-nu),(a-tu));
for(i=1;i= a-tu;)
{
printf("请输入矩阵中第%d个非零元（按行标、列标、值的顺序，空格间隔）:",i);
scanf("%d%d%d",(a-data[i].i),(a-data[i].j),(a-data[i].e));
if(a-data[i].i 1 || a-data[i].i a-mu || a-data[i].j 1 || a-data[i].j a-nu) /*下标越界*/
{
printf("注意：下标越界输入数据无效!\n请重新输入:行标范围：1--%d,列标范围1--%d!!!\n",a-mu,a-nu);
continue;
}
if( ((a-data[i].i) (a-data[i-1].i)) ||
(((a-data[i].i) == (a-data[i-1].i)) ((a-data[i].j) = (a-data[i-1].j)))) /*非按行顺序输入*/
{
printf("注意：输入数据无效!\n请按照按行存储的顺序输入数据!!!\n");
continue;
}
i++;
}
}
void DestroySMatrix(Tabletype *a)
{ /* 销毁稀疏矩阵a*/
(*a).mu=0;
(*a).nu=0;
(*a).tu=0;
}
void out_matrix(Tabletype *a) /* 打印矩阵*/
{
int i,j,k = 1;
for(i = 1 ;i = a-mu; i++)
{
for(j = 1; j= a-nu; j++)
{ /*判断是否为非零元*/
if((a-data[k].i == i)(a-data[k].j == j))
{
printf("%4d",a-data[k].e);
k++;
}
else
printf("%4d",0);
}
printf("\n");
}
}
int FastTransposeSMatrix(Tabletype *a,Tabletype *b)
{
int p,q,col;
int *num;
int *cpot;
b-mu = a-nu; /*原矩阵的行数为新矩阵的列数，原列数为新行数，非零元个数不变*/
b-nu = a-mu;
b-tu = a-tu;
num=(int *)malloc((b-nu+1)*sizeof(int)); /* 生成两个辅助数组*/
cpot=(int *)malloc((b-nu+1)*sizeof(int));
if(b-tu) /*若a不为零矩阵*/
{
for(col = 0;col a-nu;col++) /*初始化矩阵a的每列中非零元的个数均为0*/
num[col] = 0;
for(col = 0; col =a-tu ; col++)/*统计每列中非零元的个数*/
num[a-data[col].j]++;
cpot[1] = 1; /*确定每列中第一个非零元的位置*/
for(col = 2;col = a-nu; col++)
cpot[col] = num[col-1]+cpot[col-1];
for(p = 1; p = a-tu; p++) /*p为a-data的下标*/
{
col = a-data[p].j; /*交换元素*/
q = cpot[col];
b-data[q].i = a-data[p].j;
b-data[q].j = a-data[p].i;
b-data[q].e = a-data[p].e;
q++;
cpot[col]++;
}
free(num); /*释放两个辅助数组*/
free(cpot);
return 1; /*转置成功*/
}
else /*a为零矩阵*/
return 0;
Q4: C语言编写稀疏矩阵的加，减，乘和转置，要求用矩阵输出
#include stdio.h
#include iostream
#include math.h
#include stdlib.h
using namespace std;
#define Max 12500
#define Elemtype int
typedef struct {
int i ,j ;
Elemtype e;
}Triple;
typedef struct {
Triple data[Max+1];
int mu,nu,tu;
}Tsmatrix;
int Createsmatrix(Tsmatrix M)
{ int n;
cout"请输入稀疏矩阵的元素个数n"endl;
cinn;
M.tu=n;
cout"请输入稀疏矩阵的行数，列数："endl;
cinM.muM.nu;
int i;
for(i=1;i=n;i++){
cout"请输入稀疏矩阵的行下标和列下标，及数据;"endl;
cinM.data[i].iM.data[i].jM.data[i].e ;
}
return 1;
}
int Transpose(Tsmatrix M , Tsmatrix T)
{
T.mu=M.nu; T.nu=M.mu ; T.tu=M.tu;
if(T.tu){
int col , p , q=1;
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 1;
}
int Print(Tsmatrix M)
{
int i;int p=1;
{
for (i=1;i=M.mu*M.nu;i++)
if(i==((M.data[p].i-1)*M.nu+M.data[p].j))
{
if(M.data[p].j==M.nu)
{ coutM.data[p].eendl; p++;}
else
{ coutM.data[p].e" "; p++;}
}
else if(i%M.nu==0) cout"0"endl;
else cout"0 ";
}
cout"\n"endl;
return 1;
}
int Addsmatrix(Tsmatrix a, Tsmatrix b, Tsmatrix c)
{
int s=1,t=1,k=1; Elemtype temp;
if(a.mu!=b.mu||a.nu!=b.nu) return 0;
if(a.tu == 0) {c=b; return 1;}
if(b.tu==0) {c=a; return 1;}
if(a.tu==0 b.tu==0) { c=a; return 1;}
while(!(sa.tu tb.tu))
{
if(a.data[s].ib.data[t].i)
{
c.data[k]=b.data[t];
k++ ;t++;
}
if(a.data[s].ib.data[t].i)
{
c.data[k]=a.data[s];
k++ ;s++;
}
if(a.data[s].i==b.data[t].i)
{
if(a.data[s].jb.data[t].j)
{
c.data[k]=b.data[t];
k++; t++;
}
if(a.data[s].jb.data[t].j)
{
c.data[k]=a.data[s];
k++; s++;
}
if(a.data[s].j==b.data[t].j)
{
temp=a.data[s].e+b.data[t].e;
if(temp==0){s++;t++;}
else
{ c.data[k].e=temp;c.data[k].i=a.data[s].i;c.data[k].j=a.data[s].j;
s++;t++;k++;
}
}
}//if
if(sa.tut=b.tu)
{
while(t=b.tu)
{
c.data[k]=b.data[t];
k++; t++;
}
}
if(tb.tus=a.tu)
{
while(s=a.tu)
{
c.data[k]=a.data[s];
k++; s++;
}
}
}//while
c.tu=k-1; c.mu=a.mu; c.nu=a.nu;
}
return 1;int main()
{
Tsmatrix a,b,c;
Createsmatrix( a);
Createsmatrix( b);
Print(a);
Print(b);
Addsmatrix(a,b,c);
Print(c);
return 1;
}
Q5: c语言如何随机生成稀疏矩阵
在一个指定的n*m的矩阵arr中要生成一个含有k个非零元素的稀疏矩阵，可以通过下面的循环实现：
for(i=0;ik;i++)
{a=rand()%n;
b=rand()%m;
arr[a][b]=rand()%9+1;
}
c语言稀疏矩阵函数的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于c语言数据结构稀疏矩阵、c语言稀疏矩阵函数的信息别忘了在本站进行查找喔。
