稀疏矩陣c語言
Ⅰ 稀疏矩陣的轉置運算用c語言
#include<string.h>
#include<ctype.h>
#include<malloc.h> // malloc()等
#include<limits.h> // INT_MAX等
#include<stdio.h> // EOF(=^Z或F6),NULL
#include<stdlib.h> // atoi()
#include<io.h> // eof()
#include<math.h> // floor(),ceil(),abs()
#include<process.h> // exit()
#include<iostream.h> // cout,cin
// 函數結果狀態代碼
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
// #define OVERFLOW -2 因為在math.h中已定義OVERFLOW的值為3,故去掉此行
typedef int Status; // Status是函數的類型,其值是函數結果狀態代碼，如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(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.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(c1<c2)
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<=Me&&Np<=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(Mp>Me) // 矩陣M的元素全部處理完畢
while(Np<=Ne)
{
Qe++;
*Qe=*Np;
Np++;
}
if(Np>Ne) // 矩陣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;i<h*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語言
這個是稀疏矩陣相乘的演算法吧
num[col]表示矩陣M中第col列中非零元個數
rpos[row]表示矩陣N中第row行中第一個非零元在B.data中的序號，那麼rpos[row+1]-1就是矩陣B第row行中最後一個非零元在B.data的序號，而最後一行中最後一個非零元在B.data中的位置顯然就是B.tu了
這個比較繞 好好想想就理解了
Ⅲ C語言數據結構稀疏矩陣的存儲
//稀疏矩陣的十字鏈表存儲表示
#include<stdio.h>
#include<stdlib.h>
typedef int ElemType;
typedef struct OLNode
{
int i,j; //該非零元的行(i)和列(j)下標
ElemType e; //該非零元
struct OLNode *right,*down; //該非零元所在行表和列表的後繼鏈域
}OLNode,*OLink;
typedef struct
{
OLink *rhead,*chead; //行和列鏈表頭指針向量基址CreateSMartix分配
int mu,nu,tu; //稀疏矩陣的行數(mu)，列數(nu)和非零元數tu
}CrossList;
void CreateSMatrix(CrossList *M)
{
int m,n,t; //M行，N列，T非零元
int i,j,mi,mj,e;
OLink p,q;
printf("please enter matrix's row,column,element:\n");
scanf("%d %d %d",&m,&n,&t);//輸入行數，列數，非零元個數
M->mu = m; M->nu = n; M->tu = t;
printf("\n");
if(!(M->rhead=(OLink*)malloc((m+1)*sizeof(OLink)))) exit(1);
if(!(M->chead=(OLink*)malloc((n+1)*sizeof(OLink)))) exit(1);
for(i=0;i<=m;++i) //初始化行，列頭指針，使其為空鏈表
M->rhead[i] = NULL;
for(j=0;j<=n;++j)
M->chead[j] = NULL;
//按任意次序輸入非零元
for(scanf("%d %d %d",&mi,&mj,&e); mi!=0;scanf("%d %d %d",&mi,&mj,&e))
{
if(!(p = (OLink)malloc(sizeof(OLNode)))) exit(1);
p->i = mi; p->j = mj; p->e = e; //賦值
if(M->rhead[mi]==NULL)
{
p->right = M->rhead[mi];
M->rhead[mi] = p;
}
else
{
//已存在結點和比結點插入小的情況
for(q=M->rhead[mi]; q->right && q->right->j<j; q=q->right);
p->right = q->right; q->right = p;
}//完成行插入
if(M->chead[mj]==NULL )
{
p->down = M->chead[mj];
M->chead[mj] = p;
}
else
{
for(q=M->chead[mj]; q->down && q->down->i<i; q=q->down);
p->down = q->down; q->down = p;
}//完成列插入
}// for
}
void AddSMatrix(CrossList *M,CrossList *N)
{
//M與N矩陣相加結果到M中
OLink pa,pb,hj[10],pre,p;//pa,pb指向矩陣M,N,hj,pre作為前驅指針,p是臨時結點
int i,j;
pre = NULL;
for(j=1;j<=M->nu;++j) //hj取得M每列首地址
hj[j] = M->chead[j];
for(i=1;i<=M->mu;++i)
{
pa = M->rhead[i]; pb = N->rhead[i]; //分別指向行首地址
pre = pa;
while(pb)
{
//處理行的情況
if(pa==NULL || pa->j > pb->j) //pa的列比pb大時
{
p = (OLink)malloc(sizeof(OLNode));
p->i = pb->i; p->j = pb->j; p->e = pb->e; //p得到N上的值
if(M->rhead[p->i]==NULL)
{
M->rhead[p->i] = pre = p; p->right = NULL;
}
else
pre->right = p; //pa的前驅結點指向新結點p
p->right = pa; //新結點指向pa
pre = p;
//處理列
if(M->chead[p->j]==NULL) //列首地址為空
{
hj[p->j] = M->chead[p->j] = p; p->down = NULL;
}
else //列首地址不為空
{
p->down = hj[p->j]->down;
hj[p->j]->down = p;
hj[p->j] = p;
}//處理列
pb = pb->right;
}// else if pa
else if(pa->j < pb->j )//當pa的列比pb小時
{
pre = pa;pa = pa->right; //printf("pa==null?in pa->j<pb-j\n");
}
else //列相等的情況
{
pa->e += pb->e;
if(pa->e==0) //若相加等於0
{
//處理行
p = pa; //得到准備刪除結點
if(pa->right) //pa有有後繼結點則pre後移
{
pre->right = p->right;
pa = pa->right;
}
else pa = M->rhead[p->i] = NULL; //否則頭指針置空
//處理列
if(M->chead[p->j]==p)
M->chead[p->j] = hj[p->j] = p->down;
else
{
//hj[p->j]->down = p->down;
hj[p->j]->down = p->down;
}
free(p);
}
pb = pb->right;
}
//處理列的情況
}//while pa
}
}
void PrintSMatrix(CrossList *M)
{
int i;
OLink dis;
printf("i j e\n");
for(i=1;i<=M->mu;++i)
{
dis = M->rhead[i];
while(dis)
{
printf("%d %d %d\t",dis->i,dis->j,dis->e);
dis = dis->right;
}
printf("\n");
}
}
void TransposePrint(CrossList *M)
{
int i;
OLink dis;
printf("i j e\n");
for(i=1;i<=M->nu;++i)
{
dis = M->chead[i];
while(dis)
{
printf("%d %d %d\t",dis->j,dis->i,dis->e);
dis = dis->down;
}
printf("\n");
}
}
int main(void)
{
CrossList M,N;
CreateSMatrix(&M);
printf("Matrix M:\n");
PrintSMatrix(&M);
TransposePrint(&M);
CreateSMatrix(&N);
printf("Matrix N:\n");
PrintSMatrix(&N);
printf("M + N = :\n");
AddSMatrix(&M,&N);
PrintSMatrix(&M);
TransposePrint(&M);
//PrintSMatrix(&M);
return 0;
}
輸入
3 4 4
1 1 3
1 4 5
2 2 -1
3 1 2
0 0 0
3 4 4
1 3 4
2 2 7
3 1 -2
3 3 8
0 0 0
Ⅳ c語言如何隨機生成稀疏矩陣
在一個指定的n*m的矩陣arr中要生成一個含有k個非零元素的稀疏矩陣，可以通過下面的循環實現：
for(i=0;i<k;i++)
{a=rand()%n;
b=rand()%m;
arr[a][b]=rand()%9+1;
}
Ⅳ 稀疏矩陣的加法和乘法c語言（十字鏈演算法）
你沒有寫具體要求，是用採用三元組作存儲結構還是數組，下面是我們以前做過的數據結構習題你參考一下：
能區分加法、減法、乘法和轉置；能處理任意輸入的典型數據和進行出錯數據處理（例如乘法，當第一個矩陣的列數不等於第二個矩陣的行數時）；必須採用三元組作存儲結構，不能採用數組等形式；輸出要求用矩陣的形式輸出（即習題集136頁的形式），當第一個矩陣的行數不等於第二個矩陣的行數時，注意如第三個乘法的形式輸出
******************************************************************************************
#include<stdio.h>
#define maxsize 100
typedef struct
{
int i,j; //該非零元的行和列
int v; //該非零元的值
}triple;
typedef struct
{
triple data[maxsize]; //非零元三元組表，data[0]未用
int rpos[maxsize];
int m,n,t; //矩陣的行數，列數和非零元個數
}tripletable;
void convert() //矩陣的轉置
{
int k;
tripletable A,B;
printf("輸入稀疏矩陣A的行數，列數和非零元個數：");
scanf("%d %d %d",&A.m,&A.n,&A.t);
for(k=1;k<=A.t;k++)
{
printf("輸入第%d個非0元素的行數，列數和值:",k);
scanf("%d %d %d",&A.data[k].i,&A.data[k].j,&A.data[k].v);
}
B.m=A.m;B.n=A.n;B.t=A.t;
if(B.t)
{
int q=1,col;
for(col=1;col<=A.n;++col)
for(int p=1;p<=A.t;++p)
if(A.data[p].j==col)
{
B.data[q].i=A.data[p].j;
B.data[q].j=A.data[p].i;
B.data[q].v=A.data[p].v;
++q;
}
}
int shuru[100][100]={0};
for(k=1;k<=B.t;k++)
{
shuru[B.data[k].j][B.data[k].i]=B.data[k].v;
}
printf("輸入為：\n");
for(k=1;k<=B.m;k++)
{
for(int l=1;l<=B.n;l++)
printf("%d ",shuru[k][l]);
printf("\n");
}
int result[100][100]={0};
for(k=1;k<=B.t;k++)
{
result[B.data[k].i][B.data[k].j]=B.data[k].v;
}
printf("結果為：\n");
for(k=1;k<=B.n;k++)
{
for(int l=1;l<=B.m;l++)
printf("%d ",result[k][l]);
printf("\n");
}
}
void add() //矩陣的加法
{
int k;
tripletable A,B;
printf("輸入稀疏矩陣A的行數，列數和非零元個數：");
scanf("%d %d %d",&A.m,&A.n,&A.t);
for(k=1;k<=A.t;k++)
{
printf("輸入第%d個非0元素的行數，列數和值:",k);
scanf("%d %d %d",&A.data[k].i,&A.data[k].j,&A.data[k].v);
}
printf("輸入稀疏矩陣B的行數，列數和非零元個數：");
scanf("%d %d %d",&B.m,&B.n,&B.t);
for(k=1;k<=B.t;k++)
{
printf("輸入第%d個非0元素的行數，列數和值:",k);
scanf("%d %d %d",&B.data[k].i,&B.data[k].j,&B.data[k].v);
}
if(A.m!=B.m||A.n!=B.n)
{
printf("輸入錯誤：A與B的行數或列數不相同，請重新輸入\n");
return;
}
int a[100][100]={0};
for(k=1;k<=A.t;k++)
{
a[A.data[k].i][A.data[k].j]=A.data[k].v;
}
printf("A輸入為：\n");
for(k=1;k<=A.m;k++)
{
for(int l=1;l<=A.n;l++)
printf("%d ",a[k][l]);
printf("\n");
}
int b[100][100]={0};
for(k=1;k<=B.t;k++)
{
b[B.data[k].i][B.data[k].j]=B.data[k].v;
}
printf("B輸入為：\n");
for(k=1;k<=B.m;k++)
{
for(int l=1;l<=B.n;l++)
printf("%d ",b[k][l]);
printf("\n");
}
int c[100][100]={0};
for(k=1;k<=A.m;k++)
{
for(int l=1;l<=A.n;l++)
{
c[k][l]=a[k][l]+b[k][l];
}
}
printf("加法結果C為：\n");
for(k=1;k<=A.m;k++)
{
for(int l=1;l<=A.n;l++)
printf("%d ",c[k][l]);
printf("\n");
}
}
void jian() //矩陣的減法
{
int k;
tripletable A,B;
printf("輸入稀疏矩陣A的行數，列數和非零元個數：");
scanf("%d %d %d",&A.m,&A.n,&A.t);
for(k=1;k<=A.t;k++)
{
printf("輸入第%d個非0元素的行數，列數和值:",k);
scanf("%d %d %d",&A.data[k].i,&A.data[k].j,&A.data[k].v);
}
printf("輸入稀疏矩陣B的行數，列數和非零元個數：");
scanf("%d %d %d",&B.m,&B.n,&B.t);
for(k=1;k<=B.t;k++)
{
printf("輸入第%d個非0元素的行數，列數和值:",k);
scanf("%d %d %d",&B.data[k].i,&B.data[k].j,&B.data[k].v);
}
if(A.m!=B.m||A.n!=B.n)
{
printf("輸入錯誤：A與B的行數或列數不相同，請重新輸入\n");
return;
}
int a[100][100]={0};
for(k=1;k<=A.t;k++)
{
a[A.data[k].i][A.data[k].j]=A.data[k].v;
}
printf("A輸入為：\n");
for(k=1;k<=B.m;k++)
{
for(int l=1;l<=A.n;l++)
printf("%d ",a[k][l]);
printf("\n");
}
int b[100][100]={0};
for(k=1;k<=B.t;k++)
{
b[B.data[k].i][B.data[k].j]=B.data[k].v;
}
printf("B輸入為：\n");
for(k=1;k<=B.m;k++)
{
for(int l=1;l<=B.n;l++)
printf("%d ",b[k][l]);
printf("\n");
}
int c[100][100]={0};
for(k=1;k<=A.m;k++)
{
for(int l=1;l<=A.n;l++)
{
c[k][l]=a[k][l]-b[k][l];
}
}
printf("減法結果C為：\n");
for(k=1;k<=A.m;k++)
{
for(int l=1;l<=A.n;l++)
printf("%d ",c[k][l]);
printf("\n");
}
}
void multi() //矩陣的乘法
{
int k;
tripletable A,B,C;
printf("輸入稀疏矩陣A的行數，列數和非零元個數：");
scanf("%d %d %d",&A.m,&A.n,&A.t);
for(k=1;k<=A.t;k++)
{
printf("輸入第%d個非0元素的行數，列數和值:",k);
scanf("%d %d %d",&A.data[k].i,&A.data[k].j,&A.data[k].v);
}
int row=1;
for(k=1;k<=A.t;k++)
{
while(row<=A.data[k].i)
{
A.rpos[row++]=k;
}
}
while(row<=A.m)A.rpos[row++]=A.t+1;
printf("輸入稀疏矩陣B的行數，列數和非零元個數：");
scanf("%d %d %d",&B.m,&B.n,&B.t);
for(k=1;k<=B.t;k++)
{
printf("輸入第%d個非0元素的行數，列數和值:",k);
scanf("%d %d %d",&B.data[k].i,&B.data[k].j,&B.data[k].v);
}
row=1;
for(k=1;k<=B.t;k++)
{
while(row<=B.data[k].i)
{
B.rpos[row++]=k;
}
}
while(row<=B.m)B.rpos[row++]=B.t+1;
if(A.n!=B.m)
{
printf("輸入錯誤：A的列數不等於B的行數，請重新輸入\n");
return;
}
C.m=A.m;C.n=B.n;C.t=0;
int arow,p,q,ccol,t,tp;
if(A.t*B.t!=0)
{
for(arow=1;arow<=A.m;++arow)
{
int ctemp[maxsize]={0};
C.rpos[arow]=C.t+1;
if(arow<A.m){tp=A.rpos[arow+1];}
else{tp=A.t+1;}
for(p=A.rpos[arow];p<tp;++p)
{
int brow=A.data[p].j;
if(brow<B.m){t=B.rpos[brow+1];}
else{t=B.t+1;}
for(q=B.rpos[brow];q<t;++q)
{
ccol=B.data[q].j;
ctemp[ccol]+=A.data[p].v*B.data[q].v;
}
}
for(ccol=1;ccol<=C.n;++ccol)
{
if(ctemp[ccol])
{
if(++C.t>maxsize)return;
C.data[C.t].i=arow;
C.data[C.t].j=ccol;
C.data[C.t].v=ctemp[ccol];
}
}
}
}
int a[100][100]={0};
for(k=1;k<=A.t;k++)
{
a[A.data[k].i][A.data[k].j]=A.data[k].v;
}
printf("A輸入為：\n");
for(k=1;k<=A.m;k++)
{
for(int l=1;l<=A.n;l++)
printf("%d ",a[k][l]);
printf("\n");
}
int b[100][100]={0};
for(k=1;k<=B.t;k++)
{
b[B.data[k].i][B.data[k].j]=B.data[k].v;
}
printf("B輸入為：\n");
for(k=1;k<=B.m;k++)
{
for(int l=1;l<=B.n;l++)
printf("%d ",b[k][l]);
printf("\n");
}
int c[100][100]={0};
for(k=1;k<=C.t;k++)
{
c[C.data[k].i][C.data[k].j]=C.data[k].v;
}
printf("乘法結果C為：\n");
for(k=1;k<=C.m;k++)
{
for(int l=1;l<=C.n;l++)
printf("%d ",c[k][l]);
printf("\n");
}
}
void main()
{
printf("============= 菜 單 ==============\n");
printf(" 1 矩陣轉置\n");
printf(" 2 矩陣加法\n");
printf(" 3 矩陣減法\n");
printf(" 4 矩陣乘法\n");
printf("======================================\n\n");
loop: printf("請選擇相應操作的序號:");
int y;
scanf("%d",&y);
switch(y)
{
case 1: convert();
printf("\n");
goto loop;
case 2: add();
printf("\n");
goto loop;
case 3: jian();
printf("\n");
goto loop;
case 4: multi();
printf("\n");
goto loop;
}
}
Ⅵ 用C語言寫； 一個稀疏矩陣
#include<stdio.h>
#include<stdlib.h>
#define MAXSIZE 20
struct array
{
int r,c,v;
};
struct Tarray
{
array data[MAXSIZE];
int num;
int a[4][5];
}*p;
void creat_the_Tarray()//creat the array;
{
int i,j;
p=(Tarray*)malloc(sizeof(Tarray));//give the space the array;
p->num=0;//
printf(
Ⅶ 幫幫忙!!!如何用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;
Ⅷ 用C語言實現稀疏矩陣的除法
一般人在使用MATLAB時
對於矩陣的左除與右除很難正確的!區別出須要使用那一個
因此藉此機會說明一下
希望能更大家多多討論
矩陣之除法是有其特別的定義
下面是例子：
假設A矩陣為方矩陣，且有反矩陣存在；b為配合之列向量或行向量，x為與b同大小之未知向量。
則以矩陣表示之聯立方程式可以表示如下：
A*x=b
利用兩矩陣」左除」即 」 \ 」之意義可以獲得上式之解，即：
x = A\b
換言之，利用這樣的左除指令，可以解聯立方程式。
反之若方程式寫成另一種型式：
x*A=b
則其解可以用右除表示：
x=b/A
利用左除法，若A 方矩陣，則其乘冪是使用高斯遞減法解A*x=b 之矩陣方程式。
若A 不為方矩陣，則其乘冪是使用歐斯侯德之正交法，以最小平方之方式就不足或過多變數系統求解。右除法與左除法之關系實際上可表示如下：
b/A = (A'\b')'
Ⅸ 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;
cin>>n;
M.tu=n;
cout<<"請輸入稀疏矩陣的行數，列數："<<endl;
cin>>M.mu>>M.nu;
int i;
for(i=1;i<=n;i++){
cout<<"請輸入稀疏矩陣的行下標和列下標，及數據;"<<endl;
cin>>M.data[i].i>>M.data[i].j>>M.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)
{ cout<<M.data[p].e<<endl; p++;}
else
{ cout<<M.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(!(s>a.tu && t>b.tu))
{
if(a.data[s].i>b.data[t].i)
{
c.data[k]=b.data[t];
k++ ;t++;
}
if(a.data[s].i<b.data[t].i)
{
c.data[k]=a.data[s];
k++ ;s++;
}
if(a.data[s].i==b.data[t].i)
{
if(a.data[s].j>b.data[t].j)
{
c.data[k]=b.data[t];
k++; t++;
}
if(a.data[s].j<b.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(s>a.tu&&t<=b.tu)
{
while(t<=b.tu)
{
c.data[k]=b.data[t];
k++; t++;
}
}
if(t>b.tu&&s<=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;
}