稀疏矩阵运算

 行逻辑链接的三元组顺序表实现，加减乘和转置运算，调的好累，这两天少了点劲头了，坚持住，

试了好几组数据应该没问题了，但也可能还有漏洞```

 

 

5. #include<iostream>
6. #include<malloc.h>
7. #include<stdlib.h>
8. using namespace std;
10. #define OK 1
11. #define ERROR 0
12. #define OVERFLOW -2
13. typedef int Status;
14. typedef struct
15. {
16. int i,j;
17. int  e;}Triple;
18. typedef struct
19. {
20. Triple *data;
21. int *rpos;
22. int mu,nu,tu;
23. }RLSMatrix;
25. Status CreateMatrix(RLSMatrix &a)           //创建
26. {
27. cin>>a.mu>>a.nu>>a.tu;
28. a.data=(Triple*)malloc(a.tu*sizeof(Triple));
29. a.rpos=(int*)malloc((a.mu+1)*sizeof(int));
30. if(!a.data||!a.rpos) exit(OVERFLOW);
31. int curow=0,k;
32. for(k=0;k<a.tu;k++)
33. {
34.     do
35.       {
36.      cin>>a.data[k].i>>a.data[k].j>>a.data[k].e;
37.      }while(a.data[k].i>a.mu||a.data[k].j>a.nu);
38.  while(curow<a.data[k].i)
39.       a.rpos[curow++]=k;         //如果当前行元素都为0，则指向下一行第一个非0元素 
40.       }
41.  while(curow<=a.mu)
42.  a.rpos[curow++]=k;
43. return OK;
44. } 
47. /*
48. Status TransposeSMatrix(RLSMatrix a,RLSMatrix &b)               //转置
49. {
50.     b.mu=a.nu;b.nu=a.mu;b.tu=a.tu;
51.  b.data=(Triple*)malloc(b.tu*sizeof(Triple)); 
52.  b.rpos=(int*)malloc((b.mu+1)*sizeof(int));
53.  if(!b.data||!b.rpos) exit(OVERFLOW);
54.  int curow=0,k,col,p;
55.     for(col=1,k=0;col<=a.nu;col++)
56.     for(p=0;p<a.tu;p++)
57.     if(a.data[p].j==col) 
58.     {
59.     while(curow<a.data[k].j)
60.  b.rpos[curow++]=k;
61.  b.data[k].j=a.data[p].i;
62.     b.data[k].i=a.data[p].j;
63.     b.data[k].e=a.data[p].e;
64.     k++;
65.     }
66.    while(curow<=b.mu)
67.     b.rpos[curow++]=k;
68.     return OK;
69. }
71. */
73. Status FastTransposeSMatrix(RLSMatrix a,RLSMatrix &b)       //快速转置
74. {
75.  b.mu=a.nu;b.nu=a.mu;b.tu=a.tu;
76.  b.data=(Triple*)malloc(b.tu*sizeof(Triple));
77.  int col,k,m,*num,*cpot;
78.  num=(int*)malloc(a.nu*sizeof(int));
79.  cpot=(int*)malloc(a.nu*sizeof(int));
80.  b.rpos=(int*)malloc((b.mu+1)*sizeof(int));
82.  if(!b.data||!b.rpos||!num||!cpot) exit(OVERFLOW);
83.  if(b.tu)
84.  {
85.  for(col=0;col<a.nu;col++) num[col]=0;
86.  for(k=0;k<a.tu;k++)
87.   ++num[a.data[k].j-1];
88.  b.rpos[0]=cpot[0]=0;
89.  for(col=1;col<a.nu;col++) 
90.   b.rpos[col]=cpot[col]=cpot[col-1]+num[col-1];
91.   b.rpos[col]=cpot[col-1]+num[col-1];
92.  for(k=0;k<a.tu;k++)
93.         {
94.   col=a.data[k].j-1; m=cpot[col];
95.   b.data[m].i=a.data[k].j;b.data[m].j=a.data[k].i;
96.   b.data[m].e=a.data[k].e;
97.   cpot[col]++;}
98.  free(num);free(cpot);
99.    }
100. return OK;} 
103. Status AddSMatrix(RLSMatrix M,RLSMatrix N,RLSMatrix &Q)              //加法
104. {
105.    if(!(M.mu==N.mu&&M.nu==N.nu)) return ERROR;
106.    Q.mu=M.mu;Q.nu=M.nu;Q.tu=0;
107.    Q.data=(Triple*)malloc(Q.mu*Q.nu*sizeof(Triple));
108.    Q.rpos=(int*)malloc((Q.mu+1)*sizeof(int));
109.    if(!Q.data||!Q.rpos) exit(OVERFLOW);
110.    int t,tp,temp,p,q;
111.      for(int row=0;row<Q.mu;row++)
112.           {  
113.      Q.rpos[row]=Q.tu;
114.      tp=M.rpos[row+1];
115.               t=N.rpos[row+1];
116.               for(p=M.rpos[row],q=N.rpos[row];p!=tp&&q!=t;p++)
117.                     if(M.data[p].j<N.data[q].j) {
118.                           Q.data[Q.tu].i=M.data[p].i;
119.                           Q.data[Q.tu].j=M.data[p].j;                     
120.                           Q.data[Q.tu++].e=M.data[p].e;}
121.                     else if(M.data[p].j>N.data[q].j){
122.                           Q.data[Q.tu].i=N.data[q].i;
123.                           Q.data[Q.tu].j=N.data[q].j;                     
124.                           Q.data[Q.tu++].e=N.data[q++].e;}
125.                     else {
126.                           temp=M.data[p].e+N.data[q].e;
127.                           if(!temp) q++;
128.         else{
129.                                Q.data[Q.tu].i=N.data[q].i;
130.                                Q.data[Q.tu].j=N.data[q].j;                     
131.                                Q.data[Q.tu++].e=temp;
132.                                q++;}     
133.                                }
134.           
135.             while(p<tp) {Q.data[Q.tu].i=M.data[p].i;
136.                          Q.data[Q.tu].j=M.data[p].j;                     
137.                          Q.data[Q.tu++].e=M.data[p++].e;
138.                         }
139.             while (q<t){
140.                         Q.data[Q.tu].i=N.data[q].i;
141.                         Q.data[Q.tu].j=N.data[q].j;                     
142.                         Q.data[Q.tu++].e=N.data[q++].e;}
143.             
144.             
145.             }
146.   Q.rpos[Q.mu]=Q.tu;
147.         return OK;                      
148. }
150. Status SubSMatrix(RLSMatrix M,RLSMatrix N,RLSMatrix &Q)           //减法
151. {
152.    if(!(M.mu==N.mu&&M.nu==N.nu)) return ERROR;
153.    Q.mu=M.mu;Q.nu=M.nu;Q.tu=0;
154.    Q.data=(Triple*)malloc(Q.mu*Q.nu*sizeof(Triple));
155.    Q.rpos=(int*)malloc((Q.mu+1)*sizeof(int));
156.    if(!Q.data||!Q.rpos) exit(OVERFLOW);
157.    int t,tp,temp,p,q;
158.      for(int row=0;row<Q.mu;row++)
159.           {  
160.      Q.rpos[row]=Q.tu;
161.      tp=M.rpos[row+1];
162.               t=N.rpos[row+1];
163.               for(p=M.rpos[row],q=N.rpos[row];p!=tp&&q!=t;p++)
164.                     if(M.data[p].j<N.data[q].j) {
165.                           Q.data[Q.tu].i=M.data[p].i;
166.                           Q.data[Q.tu].j=M.data[p].j;                     
167.                           Q.data[Q.tu++].e=M.data[p].e;}
168.                     else if(M.data[p].j>N.data[q].j){
169.                           Q.data[Q.tu].i=N.data[q].i;
170.                           Q.data[Q.tu].j=N.data[q].j;                     
171.                           Q.data[Q.tu++].e=-N.data[q++].e;}
172.                     else {
173.                           temp=M.data[p].e-N.data[q].e;
174.                           if(!temp) q++;
175.         else{
176.                                Q.data[Q.tu].i=N.data[q].i;
177.                                Q.data[Q.tu].j=N.data[q].j;                     
178.                                Q.data[Q.tu++].e=temp;
179.                                q++;}     
180.                                }
181.           
182.             while(p<tp) {Q.data[Q.tu].i=M.data[p].i;
183.                          Q.data[Q.tu].j=M.data[p].j;                     
184.                          Q.data[Q.tu++].e=M.data[p++].e;
185.                         }
186.             while (q<t){
187.                         Q.data[Q.tu].i=N.data[q].i;
188.                         Q.data[Q.tu].j=N.data[q].j;                     
189.                         Q.data[Q.tu++].e=-N.data[q++].e;}
190.             
191.             
192.             }
193.   Q.rpos[Q.mu]=Q.tu;
194.         return OK;                      
195. }
196. Status MultSMatrix(RLSMatrix M,RLSMatrix N,RLSMatrix &Q)             //乘法
197. { 
198.        if(M.nu!=N.mu) return ERROR;
199.        Q.mu=M.mu;Q.nu=N.nu;Q.tu=-1;
200.        Q.data=(Triple*)malloc(Q.mu*Q.nu*sizeof(Triple));
201.        Q.rpos=(int*)malloc((Q.mu+1)*sizeof(int));
202.        int *ctemp=(int*)malloc(Q.nu*sizeof(int));
203.     if(!Q.data||!Q.rpos||!ctemp) exit(OVERFLOW);
204.     int tp,t,ccol,brow;
205.     if(M.tu*N.tu!=0)
206.     {
207.           for(int arow=0;arow<M.mu;arow++)
208.           {
209.               for(int i=0;i<Q.nu;i++)
210.                       ctemp[i]=0;
211.               Q.rpos[arow]=Q.tu+1;
212.               tp=M.rpos[arow+1];
213.               for(int p=M.rpos[arow];p<tp;p++)
214.                      {
215.                             brow=M.data[p].j-1;
216.                             t=N.rpos[brow+1];
217.                             for(int q=N.rpos[brow];q<t;q++)
218.                             {
219.                                     ccol=N.data[q].j-1;
220.                                     ctemp[ccol]+=M.data[p].e*N.data[q].e;
221.                                     }
222.                      }           
223.            for(ccol=0;ccol<Q.nu;++ccol)
224.              if(ctemp[ccol])
225.                  {
226.        ++Q.tu;                    
227.        Q.data[Q.tu].i=arow+1;
228.                       Q.data[Q.tu].j=ccol+1;
229.                       Q.data[Q.tu].e=ctemp[ccol];
230.                       }
231.              }
232.         Q.tu++;
233.   Q.rpos[Q.mu]=Q.tu;
234.         } 
235.         return OK; 
236. }
237.  /*                      
238. void PrintSMatrix(RLSMatrix a)               //输出rpos[]的值，用于测试
239. { 
240.    for(int i=0;i<=a.mu;i++)
241.    cout<<a.rpos[i]<<" ";
242.    cout<<endl;
243. cout<<a.tu<<endl;}
244. */
245. void ShowSMatrix(RLSMatrix a)        //输出矩阵
246. {
247. cout<<endl;
249. for(int row=1,k=0;row<=a.mu;row++)
250. {for(int col=1;col<=a.nu;col++)
251. if(a.data[k].i==row&&a.data[k].j==col)
252. {cout<<a.data[k].e<<" ";k++;}
253. else cout<<"0"<<" ";
254. cout<<endl;}
255. cout<<endl;
256. }
258. int main()
259. {
260. RLSMatrix a,b,c,d,e,f;
262. CreateMatrix(a); 
263. ShowSMatrix(a);
264. //PrintSMatrix(a);
268. CreateMatrix(b);
269. ShowSMatrix(b);
270. //PrintSMatrix(b);
274. AddSMatrix(a,b,c);
275. ShowSMatrix(c);
276. //PrintSMatrix(c);
280. SubSMatrix(a,b,d);
281. ShowSMatrix(d);
282. //PrintSMatrix(d);
286. MultSMatrix(a,b,e);
287. ShowSMatrix(e);
288. //PrintSMatrix(e);
292. FastTransposeSMatrix(a,f);
293. ShowSMatrix(f);
294. //PrintSMatrix(b);
296. return 0;
297. }