稀疏矩陣存儲c語言

『壹』 c語言根據以下描述編寫一個程序使其能完成對稀疏矩陣的壓縮與還原，即給定稀疏矩陣可以壓縮存儲一個三元組

這是數值代數中的問題，對於不同的稀疏矩陣有著不同的演算法，你可查閱數值代數的書籍，找到對應的演算法，根據演算法就很好編寫了

『貳』 用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語言實現稀疏矩陣的除法

一般人在使用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 <iostream>
#include <iomanip>
using namespace std;

template<class T>
//三元組
struct Trituple
{
int row;
int col;
T val;
};
//稀疏矩陣聲明
template<class T>
class SparseMatrix
{
public:
SparseMatrix(int maxt=100);
~SparseMatrix();
bool TransposeTo(SparseMatrix &);
bool AddTo(const SparseMatrix&);
bool TransposeTo_Faster(SparseMatrix&);
void Input();
void Output();
private:
Trituple<T>* data;
int rows,cols,terms;
int maxterms;
};
template<class T>
SparseMatrix<T>::SparseMatrix(int maxt)
{
maxterms=maxt;
data=new Trituple<T>[maxterms];
terms=rows=cols=0;
}
template<class T>
SparseMatrix<T>::~SparseMatrix()
{
if (data!=NULL)
{
delete[] data;
}
}
//普通轉置
template<class T>
bool SparseMatrix<T>::TransposeTo(SparseMatrix &B)
{
if (terms>B.maxterms)
{
return false;
}
B.rows=cols;
B.cols=rows;
B.terms=terms;
if (terms>0)
{
int p=0;
for (int j=1;j<=cols;j++)
{
for (int k=0;k<terms;k++)
{
if (data[k].col==j)
{
B.data[p].row=j;
B.data[p].col=data[k].row;
B.data[p].val=data[k].val;
p++;
}
}
}
}
return true;
}
//快速轉置
template<class T>
bool SparseMatrix<T>::TransposeTo_Faster(SparseMatrix& B)
{
if (terms>B.maxterms)
{
return false;
}
B.rows=cols;
B.cols=rows;
B.terms=terms;
if (terms>0)
{
int *num,*cpot;
num=new int[cols];
cpot=new int[cols];
for (int j=0;j<cols;j++)
{
num[j]=0;
}
for (int k=0;k<terms;k++)
{
num[data[k].col-1]++;
}
//求出B中每一行的起始下標cpot[]
cpot[0]=0;
for (int j=1;j<cols;j++)
{
cpot[j]=cpot[j-1]+num[j-1];
}
//執行轉置操作
for (int p,k=0;k<terms;k++)
{
p=cpot[data[k].col-1]++;
B.data[p].row=data[k].col;
B.data[p].col=data[k].row;
B.data[p].val=data[k].val;
}
delete[] num;
delete[] cpot;
}
return true;
}
template<class T>
void SparseMatrix<T>::Input()
{
cout<<"intput the matrix' row:";
int row1;
cin>>row1;
cout<<"intput the matrix' col:";
int col1;
cin>>col1;
cout<<"input "<<row1<<"*"<<col1<<" matrix"<<endl;
int number;
rows=row1;
cols=col1;
for (int i=0;i<rows;i++)
{
for (int j=0;j<cols;j++)
{
cin>>number;
if (number!=0)
{
data[terms].row=i+1;
data[terms].col=j+1;
data[terms].val=number;
terms++;
}
}
}
}
template<class T> //輸出好看，但是違背了最初的原則
void SparseMatrix<T>::Output()
{
T **tempArray=new T*[rows];
for (int i1=0;i1<rows;i1++)
{
tempArray[i1]=new int[cols];
}
for (int j=0;j<rows;j++)
{
for (int k=0;k<cols;k++)
{
tempArray[j][k]=0;
}
}
for (int i=0;i<terms;i++)
{
tempArray[data[i].row-1][data[i].col-1]=data[i].val;
}
for (int j=0;j<rows;j++)
{
for (int k=0;k<cols;k++)
{
cout<<setw(4)<<tempArray[j][k];
}
cout<<endl;
}
for (int l=0;l<rows;l++)
{
delete[] tempArray[l];
}
delete tempArray;
cout<<endl;
}
template<class T>
bool SparseMatrix<T>::AddTo(const SparseMatrix& B)
{
if (rows!=B.rows||cols!=B.cols)
{
return false;
}
bool flag=false;
int tempTerms=terms;
for (int i=0;i<B.terms;i++)
{
flag=false;
for (int j=0;j<tempTerms;j++)
{
if (data[j].col==B.data[i].col&&data[j].row==B.data[i].row)
{
data[j].val+=B.data[i].val;
flag=true;
}
}
if (flag==false)
{
data[++terms-1].col=B.data[i].col; //數組下標操作注意事項
data[terms-1].row=B.data[i].row;
data[terms-1].val=B.data[i].val;
}
}
return true;
}
int main()
{
cout<<"此程序演示稀疏矩陣的普通轉置和快速轉置操作"<<endl;
SparseMatrix<int> sm(50);
SparseMatrix<int> sm1(50);
SparseMatrix<int> sm2(50);
sm.Input();
cout<<"sm is"<<endl;
sm.Output();
sm.TransposeTo(sm1);
cout<<"Transposition of sm is "<<endl;
sm1.Output();
sm.TransposeTo_Faster(sm2);
cout<<"Transposition of sm is "<<endl;
sm2.Output();
SparseMatrix<int> sm3;
cout<<"input a new matrix"<<endl;
sm3.Input();
cout<<"sm3 is"<<endl;
sm3.Output();
if(sm.AddTo(sm3))
{
cout<<"after adding sm3 ,sm is"<<endl;
sm.Output();
}
else
cout<<"the two matrix can't add"<<endl;
cout<<"Good job!"<<endl;
system("pause");
return 0;
}

『伍』 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實現：將二維數組中存放的稀疏矩陣壓縮存儲於三元組表中

悲劇了，三元組表我都不知道是什麼。

『柒』 稀疏矩陣的轉置運算用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);
}

稀疏矩陣三元組轉置，你參考下