稀疏矩阵的基本运算

 

Code:

1. #include <stdio.h>   
2. #define M 4  
3. #define N 4  
4. typedef int ElemType;  
5. #define MaxSize  100        //矩阵中非零元素最多个数  
6. #include"D:/三元组.cpp"     
7.   
8. int value(TSMatrix c,int i,int j)       //返回指定位置元素的值  
9. {  
10.     int k=0;  
11.     while (k<c.nums && (c.data[k].r!=i || c.data[k].c!=j))   
12.         k++;  
13.     if (k<c.nums)   
14.         return(c.data[k].d);  
15.     else   
16.         return(0);  
17. }  
18.   
19. int MatAdd(TSMatrix a,TSMatrix b,TSMatrix &c)  //相加  
20. {  
21.       int i=0,j=0,k=0;  
22.       ElemType v;  
23.       if (a.rows!=b.rows || a.cols!=b.cols)  
24.         return 0;                //行数或列数不等时不能进行相加运算  
25.       c.rows=a.rows;c.cols=a.cols; //c的行列数与a的相同  
26.       while (i<a.nums && j<b.nums) //处理a和b中的每个元素  
27.       {   
28.            if (a.data[i].r==b.data[j].r)    //行号相等时  
29.           {   
30.                if(a.data[i].c<b.data[j].c) //a元素的列号小于b元素的列号  
31.               {   
32.                    c.data[k].r=a.data[i].r;//将a元素添加到c中  
33.                    c.data[k].c=a.data[i].c;  
34.                    c.data[k].d=a.data[i].d;  
35.                    k++;i++;  
36.         }  
37.         else if (a.data[i].c>b.data[j].c)//a元素的列号大于b元素的列号  
38.              {    
39.                 c.data[k].r=b.data[j].r;    //将b元素添加到c中  
40.             c.data[k].c=b.data[j].c;  
41.             c.data[k].d=b.data[j].d;  
42.           k++;j++;  
43.        }  
44.         else    //a元素的列号等于b元素的列号  
45.              {    
46.                   v=a.data[i].d+b.data[j].d;  
47.                   if (v!=0) //只将不为0的结果添加到c中  
48.                  {    
49.                       c.data[k].r=a.data[i].r;  
50.                       c.data[k].c=a.data[i].c;  
51.                       c.data[k].d=v;  
52.                       k++;  
53.                  }  
54.                  i++;j++;  
55.          }  
56.           }  
57.       else if (a.data[i].r<b.data[j].r) //a元素的行号小于b元素的行号  
58.          {    
59.               c.data[k].r=a.data[i].r;    //将a元素添加到c中  
60.               c.data[k].c=a.data[i].c;  
61.               c.data[k].d=a.data[i].d;  
62.             k++;i++;  
63.          }  
64.      else                             //a元素的行号大于b元素的行号  
65.          {    
66.               c.data[k].r=b.data[j].r;    //将b元素添加到c中  
67.               c.data[k].c=b.data[j].c;  
68.               c.data[k].d=b.data[j].d;  
69.               k++;j++;  
70.      }  
71.      c.nums=k;  
72.       }  
73.       return 1;  
74. }  
75.   
76. int MatMultiply2(TSMatrix a,int k,TSMatrix &c)//k*矩阵  
77. {     
78.        
79.     int i,j,p=0;  
80.     ElemType v;  
81.     for(i=0;i<a.rows;i++)  
82.     {  
83.        for(j=0;j<a.cols;j++)  
84.        {    
85.            v=value(a,i,j);  
86.            if(v!=0)  
87.            {  
88.                c.data[p].r=i;  
89.                c.data[p].c=j;  
90.                c.data[p].d=k*v;  
91.                p++;  
92.            }  
93.        }  
94.     }  
95.     c.nums=p;  
96.     return 1;  
97. }  
98.   
99. int MatSubtract(TSMatrix a,TSMatrix b,TSMatrix &c)  //相减  
100. {   
101.     if (a.rows!=b.rows || a.cols!=b.cols)  
102.         return 0;     
103.     else  
104.     {  
105.         MatMultiply2(b,-1,b);    //重要  
106.         MatAdd(a,b,c);           //重要  
107.     }  
108.     return 1;  
109. }  
110.        
111.   
112. int MatMultiply(TSMatrix a,TSMatrix b,TSMatrix &c)   //相乘  
113. {  
114.     int i,j,k,p=0;  
115.     ElemType s;  
116.     if (a.cols!=b.rows)     //a的列数不等于b的行数时不能进行相乘运算  
117.         return 0;  
118.     for (i=0;i<a.rows;i++)  
119.         for (j=0;j<b.cols;j++)   
120.         {  
121.             s=0;  
122.             for (k=0;k<a.cols;k++)  
123.                 s=s+value(a,i,k)*value(b,k,j);  
124.             if (s!=0)     //产生一个三元组元素  
125.             {  
126.                 c.data[p].r=i;  
127.                 c.data[p].c=j;  
128.                 c.data[p].d=s;  
129.                 p++;  
130.             }  
131.         }  
132.     c.nums=p;   
133.     return 1;  
134. }  
135.   
136.   
137.   
138. void main()  
139. {  
140.     TSMatrix a,b,c;  
141.   
142.     ElemType a1[M][N]={{1,0,3,0},{0,1,0,0},{0,0,1,0},{0,0,1,1}};  
143.     ElemType b1[M][N]={{3,0,0,0},{0,4,0,0},{0,0,1,0},{0,0,0,2}};  
144.   
145.     CreatMat(a,a1);  
146.     CreatMat(b,b1);  
147.     printf("a的三元组:/n");DispMat(a);  
148.     printf("b的三元组:/n");DispMat(b);  
149.   
150.     printf("a转置为c/n");  
151.     TranTat(a,c);DispMat(c);  
152.   
153.     printf("c=a+b/n");  
154.     MatAdd(a,b,c); DispMat(c);  
155.      
156.     printf("c=a-b/n");    
157.     MatSubtract(a,b,c);DispMat(c);  
158.   
159.     printf("c=a*b/n");  
160.     MatMultiply(a,b,c);DispMat(c);  
161.   
162.    
163. }  
164.   
165. //三元组文件  
166. //稀疏矩阵的三元组表示  
167.    
168. typedef int ElemType;  
169. typedef struct   
170. {  
171.     int r;                  //行号  
172.     int c;                  //列号  
173.     ElemType d;             //元素值  
174. } TupNode;                  //三元组定义  
175. typedef struct   
176. {     
177.     int rows;               //行数值  
178.     int cols;               //列数值  
179.     int nums;               //非零元素个数  
180.     TupNode data[MaxSize];  
181. } TSMatrix;                     //三元组顺序表定义  
182.   
183. void CreatMat(TSMatrix &t,ElemType A[M][N])     //从一个二维矩阵创建其三元组表示  
184. {                                               //以行序方式扫描矩阵A,将其非零元素插入到三元组t中  
185.     int i,j;  
186.     t.rows=M;t.cols=N;t.nums=0;  
187.     for (i=0;i<M;i++)  
188.     {  
189.         for (j=0;j<N;j++)   
190.             if (A[i][j]!=0)     //只存储非零元素  
191.             {  
192.                 t.data[t.nums].r=i;t.data[t.nums].c=j;  
193.                 t.data[t.nums].d=A[i][j];t.nums++;  
194.             }  
195.     }  
196. }  
197.   
198. int Value(TSMatrix &t,ElemType x,int rs,int cs) //三元组元素赋值  
199. {                                               //先在三元组t中找到适当的位置k,将k~t.nums个元素后移一个位置,将指定元素x插入到t.data[k]处  
200.     int i,k=0;  
201.     if (rs>=t.rows || cs>=t.cols)  
202.         return 0;  
203.     while (k<t.nums && rs>t.data[k].r) k++; //查找行  
204.     while (k<t.nums && rs==t.data[k].r && cs>t.data[k].c) k++;  //查找列  
205.     if (t.data[k].r==rs && t.data[k].c==cs) //存在这样的元素  
206.         t.data[k].d=x;  
207.     else                                    //不存在这样的元素时插入一个元素  
208.     {  
209.         for (i=t.nums-1;i>=k;i--)   
210.         {  
211.             t.data[i+1].r=t.data[i].r;  
212.             t.data[i+1].c=t.data[i].c;  
213.             t.data[i+1].d=t.data[i].d;  
214.         }  
215.         t.data[k].r=rs;t.data[k].c=cs;t.data[k].d=x;  
216.         t.nums++;  
217.     }  
218.     return 1;  
219. }  
220.   
221. int Assign(TSMatrix t,ElemType &x,int rs,int cs) //将指定位置的元素值赋给变量  
222. {  
223.     int k=0;  
224.     if (rs>=t.rows || cs>=t.cols)  
225.         return 0;  
226.     while (k<t.nums && rs>t.data[k].r) k++;  
227.     while (k<t.nums && rs==t.data[k].r && cs>t.data[k].c) k++;  
228.     if (t.data[k].r==rs && t.data[k].c==cs)   
229.     {  
230.         x=t.data[k].d;  
231.         return 1;     
232.     }  
233.     else    
234.         return 0;  
235. }  
236.   
237. void DispMat(TSMatrix t)                        //输出三元组  
238. {  
239.     int i;  
240.     if (t.nums<=0) return;  
241.     printf("/t%d/t%d/t%d/n",t.rows,t.cols,t.nums);  
242.     printf("/t------------------/n");  
243.     for (i=0;i<t.nums;i++)  
244.         printf("/t%d/t%d/t%d/n",t.data[i].r,t.data[i].c,t.data[i].d);  
245. }  
246.      
247. void TranTat(TSMatrix t,TSMatrix &tb)           //矩阵转置  
248. {  
249.     int p,q=0,v;                    //q为tb.data的下标  
250.     tb.rows=t.cols;tb.cols=t.rows;tb.nums=t.nums;  
251.     if (t.nums!=0)   
252.     {  
253.         for (v=0;v<t.cols;v++)      //tb.data[q]中的记录以c域的次序排列  
254.             for (p=0;p<t.nums;p++)  //p为t.data的下标  
255.                 if (t.data[p].c==v)   
256.                 {  
257.                     tb.data[q].r=t.data[p].c;  
258.                     tb.data[q].c=t.data[p].r;  
259.                     tb.data[q].d=t.data[p].d;  
260.                     q++;  
261.                 }  
262.     }  
263. }  
264.   
265.