稀疏矩阵的十字链表存储表示和实现

  1 #include <stdio.h>
  2 #include <malloc.h>
  3 typedef int ElemType;// 稀疏矩阵的十字链表存储表示 
  4 typedef struct OLNode
  5 {
  6     int i,j;    // 该非零元的行和列下标 
  7     ElemType e;    // 非零元素值 
  8     struct OLNode *right,*down; // 该非零元所在行表和列表的后继链域 
  9 }OLNode, *OLink;
 10 typedef struct// 行和列链表头指针向量基址,由CreatSMatrix_OL()分配
 11 {
 12     OLink *rhead, *chead; 
 13     int mu, nu, tu;        // 稀疏矩阵的行数、列数和非零元个数 
 14 }CrossList;
 15 // 初始化M(CrossList类型的变量必须初始化,否则创建、复制矩阵将出错) 
 16 int InitSMatrix(CrossList *M)
 17 {
 18     (*M).rhead=(*M).chead=NULL;
 19     (*M).mu=(*M).nu=(*M).tu=0;
 20     return 1;
 21 }
 22 // 销毁稀疏矩阵M
 23 int DestroySMatrix(CrossList *M)
 24 {
 25     int i;
 26     OLNode *p,*q;
 27     
 28     for(i=1;i<=(*M).mu;i++) // 按行释放结点 
 29     {
 30         p=*((*M).rhead+i);
 31         while(p)
 32         {
 33             q=p;
 34             p=p->right;
 35             free(q);
 36         }
 37     }
 38     free((*M).rhead);
 39     free((*M).chead);
 40     (*M).rhead=(*M).chead=NULL;
 41     (*M).mu=(*M).nu=(*M).tu=0;
 42     return 1;
 43 }
 44 // 创建稀疏矩阵M,采用十字链表存储表示。
 45 int CreateSMatrix(CrossList *M)
 46 { 
 47     int i,j,k,m,n,t;
 48     ElemType e;
 49     OLNode *p,*q;
 50     if((*M).rhead)
 51     DestroySMatrix(M);
 52     printf("请输入稀疏矩阵的行数 列数 非零元个数:(space) ");
 53     scanf("%d%d%d",&m,&n,&t);
 54     (*M).mu=m;
 55     (*M).nu=n;
 56     (*M).tu=t;
 57     //初始化行链表头
 58     (*M).rhead=(OLink*)malloc((m+1)*sizeof(OLink));
 59     if(!(*M).rhead)
 60         exit(0);
 61     //初始化列链表头
 62     (*M).chead=(OLink*)malloc((n+1)*sizeof(OLink));
 63     if(!(*M).chead)
 64         exit(0);
 65     for(k=1;k<=m;k++) // 初始化行头指针向量;各行链表为空链表 
 66         (*M).rhead[k]=NULL;
 67     for(k=1;k<=n;k++) // 初始化列头指针向量;各列链表为空链表 
 68         (*M).chead[k]=NULL;
 69     printf("请按任意次序输入%d个非零元的行 列 元素值:(空格)\n",(*M).tu);
 70     for(k=0;k<t;k++)
 71     {
 72         scanf("%d%d%d",&i,&j,&e);
 73         p=(OLNode*)malloc(sizeof(OLNode));
 74         if(!p)
 75             exit(0);
 76         p->i=i; // 生成结点 
 77         p->j=j;
 78         p->e=e;
 79         if((*M).rhead[i]==NULL||(*M).rhead[i]->j>j)    
 80         {
 81             // p插在该行的第一个结点处
 82             p->right=(*M).rhead[i];
 83             (*M).rhead[i]=p;
 84         }
 85         else // 寻查在行表中的插入位置 
 86         {
 87             //从该行的行链表头开始,直到找到
 88             for(q=(*M).rhead[i]; q->right && q->right->j < j;q = q->right)
 89                 ;
 90             p->right=q->right; // 完成行插入 
 91             q->right=p;
 92         }
 93         if((*M).chead[j] == NULL || (*M).chead[j]->i > i) 
 94         {
 95             // p插在该列的第一个结点处
 96             p->down = (*M).chead[j];
 97             (*M).chead[j] = p;
 98         }
 99         else // 寻查在列表中的插入位置 
100         {
101             for(q = (*M).chead[j];q->down && q->down->i < i;q = q->down)
102                 ;
103             p->down=q->down; // 完成列插入 
104             q->down=p;
105         }
106     }
107     return 1;
108 }
109 // 按行或按列输出稀疏矩阵M
110 int PrintSMatrix(CrossList M)
111 {
112     int i,j;
113     OLink p;
114     printf("%d行%d列%d个非零元素\n",M.mu,M.nu,M.tu);
115     printf("请输入选择(1.按行输出 2.按列输出): ");
116     scanf("%d",&i);
117     switch(i)
118     {
119     case 1: 
120         for(j=1;j<=M.mu;j++)
121         {
122             p=M.rhead[j];
123             while(p)
124             {
125                 printf("%d行%d列值为%d\n",p->i,p->j,p->e);
126                 p=p->right;
127             }
128         }
129         break;
130     case 2: 
131         for(j=1;j<=M.nu;j++)
132         {
133             p=M.chead[j];
134             while(p)
135             {
136                 printf("%d行%d列值为%d\n",p->i,p->j,p->e);
137                 p=p->down;
138             }
139         }
140     }
141     return 1;
142 }
143 // 由稀疏矩阵M复制得到T
144 int CopySMatrix(CrossList M,CrossList *T)
145 {
146     int i;
147     OLink p,q,q1,q2;
148     
149     if((*T).rhead)
150         DestroySMatrix(T);
151     (*T).mu=M.mu;
152     (*T).nu=M.nu;
153     (*T).tu=M.tu;
154     (*T).rhead=(OLink*)malloc((M.mu+1)*sizeof(OLink));
155     if(!(*T).rhead)
156         exit(0);
157     (*T).chead=(OLink*)malloc((M.nu+1)*sizeof(OLink));
158     if(!(*T).chead)
159         exit(0);
160     for(i=1;i<=M.mu;i++) // 初始化矩阵T的行头指针向量;各行链表为空链表 
161         (*T).rhead[i]=NULL;
162     for(i=1;i<=M.nu;i++) // 初始化矩阵T的列头指针向量;各列链表为空链表 
163         (*T).chead[i]=NULL;
164     for(i=1;i<=M.mu;i++) // 按行复制 
165     {
166         p=M.rhead[i];
167         while(p) // 没到行尾 
168         {
169             q=(OLNode*)malloc(sizeof(OLNode)); // 生成结点 
170             if(!q)
171                 exit(0);
172             q->i=p->i; // 给结点赋值 
173             q->j=p->j;
174             q->e=p->e;
175             if(!(*T).rhead[i]) // 插在行表头 
176                 (*T).rhead[i]=q1=q;
177             else // 插在行表尾 
178                 q1=q1->right=q;
179             if(!(*T).chead[q->j]) // 插在列表头 
180             {
181                 (*T).chead[q->j]=q;
182                 q->down=NULL;
183             }
184             else // 插在列表尾 
185             {
186                 q2=(*T).chead[q->j];
187                 while(q2->down)
188                     q2=q2->down;
189                 q2->down=q;
190                 q->down=NULL;
191             }
192             p=p->right;
193         }
194         q->right=NULL;
195     }
196     return 1;
197 }
198 // 求稀疏矩阵的和Q=M+N
199 int AddSMatrix(CrossList M,CrossList N,CrossList *Q)
200 {
201     int i,k;
202     OLink p,pq,pm,pn;
203     OLink *col;
204     
205     if(M.mu!=N.mu||M.nu!=N.nu)
206     {
207         printf("两个矩阵不是同类型的,不能相加\n");
208         exit(0);
209     }
210     (*Q).mu=M.mu; // 初始化Q矩阵 
211     (*Q).nu=M.nu;
212     (*Q).tu=0; // 元素个数的初值 
213     (*Q).rhead=(OLink*)malloc(((*Q).mu+1)*sizeof(OLink));
214     if(!(*Q).rhead)
215         exit(0);
216     (*Q).chead=(OLink*)malloc(((*Q).nu+1)*sizeof(OLink));
217     if(!(*Q).chead)
218         exit(0);
219     for(k=1;k<=(*Q).mu;k++) // 初始化Q的行头指针向量;各行链表为空链表 
220         (*Q).rhead[k]=NULL;
221     for(k=1;k<=(*Q).nu;k++) // 初始化Q的列头指针向量;各列链表为空链表 
222         (*Q).chead[k]=NULL;
223     // 生成指向列的最后结点的数组 
224     col=(OLink*)malloc(((*Q).nu+1)*sizeof(OLink)); 
225     if(!col)
226         exit(0);
227     for(k=1;k<=(*Q).nu;k++) // 赋初值 
228         col[k]=NULL;
229     for(i=1;i<=M.mu;i++) // 按行的顺序相加 
230     {
231         pm=M.rhead[i];    // pm指向矩阵M的第i行的第1个结点 
232         pn=N.rhead[i];    // pn指向矩阵N的第i行的第1个结点 
233         while(pm&&pn)    // pm和pn均不空 
234         {
235             if(pm->j<pn->j) // 矩阵M当前结点的列小于矩阵N当前结点的列 
236             {
237                 p=(OLink)malloc(sizeof(OLNode)); // 生成矩阵Q的结点 
238                 if(!p)
239                     exit(0);
240                 (*Q).tu++;    // 非零元素数加1 
241                 p->i=i;        // 给结点赋值 
242                 p->j=pm->j;
243                 p->e=pm->e;
244                 p->right=NULL;
245                 pm=pm->right; // pm指针向右移 
246             }
247             else if(pm->j>pn->j)// 矩阵M当前结点的列大于矩阵N当前结点的列 
248             {
249                 p=(OLink)malloc(sizeof(OLNode)); // 生成矩阵Q的结点 
250                 if(!p)
251                     exit(0);
252                 (*Q).tu++;    // 非零元素数加1 
253                 p->i=i;        // 给结点赋值 
254                 p->j=pn->j;
255                 p->e=pn->e;
256                 p->right=NULL;
257                 pn=pn->right; // pn指针向右移 
258             }
259             // 矩阵M、N当前结点的列相等且两元素之和不为0
260             else if(pm->e+pn->e) 
261             {
262                 p=(OLink)malloc(sizeof(OLNode)); // 生成矩阵Q的结点 
263                 if(!p)
264                     exit(0);
265                 (*Q).tu++; // 非零元素数加1 
266                 p->i=i; // 给结点赋值 
267                 p->j=pn->j;
268                 p->e=pm->e+pn->e;
269                 p->right=NULL;
270                 pm=pm->right; // pm指针向右移 
271                 pn=pn->right; // pn指针向右移 
272             }
273             else // 矩阵M、N当前结点的列相等且两元素之和为0 
274             {
275                 pm=pm->right; // pm指针向右移 
276                 pn=pn->right; // pn指针向右移 
277                 continue;
278             }
279             if((*Q).rhead[i]==NULL) // p为该行的第1个结点
280                 // p插在该行的表头且pq指向p(该行的最后一个结点) 
281                 (*Q).rhead[i]=pq=p; 
282             else // 插在pq所指结点之后 
283             {
284                 pq->right=p; // 完成行插入 
285                 pq=pq->right; // pq指向该行的最后一个结点 
286             }
287             if((*Q).chead[p->j]==NULL) // p为该列的第1个结点
288                  // p插在该列的表头且col[p->j]指向p  
289                 (*Q).chead[p->j]=col[p->j]=p;
290             else // 插在col[p->]所指结点之后 
291             {
292                 col[p->j]->down=p; // 完成列插入
293                  // col[p->j]指向该列的最后一个结点 
294                 col[p->j]=col[p->j]->down;
295             }
296         }
297         while(pm) // 将矩阵M该行的剩余元素插入矩阵Q 
298         {
299             p=(OLink)malloc(sizeof(OLNode)); // 生成矩阵Q的结点 
300             if(!p)
301                 exit(0);
302             (*Q).tu++; // 非零元素数加1 
303             p->i=i; // 给结点赋值 
304             p->j=pm->j;
305             p->e=pm->e;
306             p->right=NULL;
307             pm=pm->right; // pm指针向右移 
308             if((*Q).rhead[i] == NULL) // p为该行的第1个结点 
309                 // p插在该行的表头且pq指向p(该行的最后一个结点)
310                 (*Q).rhead[i] = pq = p;  
311             else // 插在pq所指结点之后 
312             {
313                 pq->right=p; // 完成行插入 
314                 pq=pq->right; // pq指向该行的最后一个结点 
315             }
316             if((*Q).chead[p->j] == NULL) // p为该列的第1个结点
317                  // p插在该列的表头且col[p->j]指向p 
318                 (*Q).chead[p->j] = col[p->j] = p; 
319             else // 插在col[p->j]所指结点之后 
320             {
321                 col[p->j]->down=p; // 完成列插入
322                 // col[p->j]指向该列的最后一个结点 
323                 col[p->j]=col[p->j]->down;  
324             }
325         }
326         while(pn) // 将矩阵N该行的剩余元素插入矩阵Q 
327         {
328             p=(OLink)malloc(sizeof(OLNode)); // 生成矩阵Q的结点 
329             if(!p)
330                 exit(0);
331             (*Q).tu++; // 非零元素数加1 
332             p->i=i; // 给结点赋值 
333             p->j=pn->j;
334             p->e=pn->e;
335             p->right=NULL;
336             pn=pn->right; // pm指针向右移 
337             if((*Q).rhead[i]==NULL) // p为该行的第1个结点 
338                 // p插在该行的表头且pq指向p(该行的最后一个结点)
339                 (*Q).rhead[i]=pq=p;  
340             else // 插在pq所指结点之后 
341             {
342                 pq->right=p; // 完成行插入 
343                 pq=pq->right; // pq指向该行的最后一个结点 
344             }
345             if((*Q).chead[p->j]==NULL) // p为该列的第1个结点
346                 // p插在该列的表头且col[p->j]指向p  
347                 (*Q).chead[p->j]=col[p->j]=p; 
348             else // 插在col[p->j]所指结点之后 
349             {
350                 col[p->j]->down=p; // 完成列插入
351                 // col[p->j]指向该列的最后一个结点 
352                 col[p->j]=col[p->j]->down;  
353             }
354         }
355     }
356     for(k=1;k<=(*Q).nu;k++)
357         if(col[k]) // k列有结点 
358             col[k]->down=NULL; //  令该列最后一个结点的down指针为空 
359     free(col);
360     return 1;
361 }
362 
363 //  求稀疏矩阵的差Q=M-N 
364 int SubtSMatrix(CrossList M,CrossList N,CrossList *Q)
365 {
366     int i,k;
367     OLink p,pq,pm,pn;
368     OLink *col;
369     
370     if(M.mu!=N.mu||M.nu!=N.nu)
371     {
372         printf("两个矩阵不是同类型的,不能相加\n");
373         exit(0);
374     }
375     (*Q).mu=M.mu; // 初始化Q矩阵 
376     (*Q).nu=M.nu;
377     (*Q).tu=0; // 元素个数的初值 
378     (*Q).rhead=(OLink*)malloc(((*Q).mu+1)*sizeof(OLink));
379     if(!(*Q).rhead)
380         exit(0);
381     (*Q).chead=(OLink*)malloc(((*Q).nu+1)*sizeof(OLink));
382     if(!(*Q).chead)
383         exit(0);
384     for(k=1;k<=(*Q).mu;k++) // 初始化Q的行头指针向量;各行链表为空链表 
385         (*Q).rhead[k]=NULL;
386     for(k=1;k<=(*Q).nu;k++) // 初始化Q的列头指针向量;各列链表为空链表 
387         (*Q).chead[k]=NULL;
388     // 生成指向列的最后结点的数组
389     col=(OLink*)malloc(((*Q).nu+1)*sizeof(OLink)); 
390     if(!col)
391         exit(0);
392     for(k=1;k<=(*Q).nu;k++) // 赋初值 
393         col[k]=NULL;
394     for(i=1;i<=M.mu;i++) // 按行的顺序相加 
395     {
396         pm=M.rhead[i]; // pm指向矩阵M的第i行的第1个结点 
397         pn=N.rhead[i]; // pn指向矩阵N的第i行的第1个结点 
398         while(pm&&pn) // pm和pn均不空 
399         {
400             if(pm->j<pn->j) // 矩阵M当前结点的列小于矩阵N当前结点的列 
401             {
402                 p=(OLink)malloc(sizeof(OLNode)); // 生成矩阵Q的结点 
403                 if(!p)
404                     exit(0);
405                 (*Q).tu++; // 非零元素数加1 
406                 p->i=i; // 给结点赋值 
407                 p->j=pm->j;
408                 p->e=pm->e;
409                 p->right=NULL;
410                 pm=pm->right; // pm指针向右移 
411             }
412             // 矩阵M当前结点的列大于矩阵N当前结点的列 
413             else if(pm->j>pn->j) 
414             {
415                 p=(OLink)malloc(sizeof(OLNode)); // 生成矩阵Q的结点 
416                 if(!p)
417                     exit(0);
418                 (*Q).tu++; // 非零元素数加1 
419                 p->i=i; // 给结点赋值 
420                 p->j=pn->j;
421                 p->e=-pn->e;
422                 p->right=NULL;
423                 pn=pn->right; // pn指针向右移 
424             }
425             else if(pm->e-pn->e) 
426             {
427                 // 矩阵M、N当前结点的列相等且两元素之差不为0 
428                 p=(OLink)malloc(sizeof(OLNode)); // 生成矩阵Q的结点 
429                 if(!p)
430                     exit(0);
431                 (*Q).tu++; // 非零元素数加1 
432                 p->i=i; // 给结点赋值 
433                 p->j=pn->j;
434                 p->e=pm->e-pn->e;
435                 p->right=NULL;
436                 pm=pm->right; // pm指针向右移 
437                 pn=pn->right; // pn指针向右移 
438             }
439             else // 矩阵M、N当前结点的列相等且两元素之差为0 
440             {
441                 pm=pm->right; // pm指针向右移 
442                 pn=pn->right; // pn指针向右移 
443                 continue;
444             }
445             if((*Q).rhead[i]==NULL) // p为该行的第1个结点 
446                 // p插在该行的表头且pq指向p(该行的最后一个结点)
447                 (*Q).rhead[i]=pq=p;  
448             else // 插在pq所指结点之后 
449             {
450                 pq->right=p; // 完成行插入 
451                 pq=pq->right; // pq指向该行的最后一个结点 
452             }
453             if((*Q).chead[p->j]==NULL) // p为该列的第1个结点 
454                 // p插在该列的表头且col[p->j]指向p
455                 (*Q).chead[p->j]=col[p->j]=p;  
456             else // 插在col[p->]所指结点之后 
457             {
458                 col[p->j]->down=p; // 完成列插入
459                 // col[p->j]指向该列的最后一个结点 
460                 col[p->j]=col[p->j]->down;  
461             }
462         }
463         while(pm) // 将矩阵M该行的剩余元素插入矩阵Q 
464         {
465             p=(OLink)malloc(sizeof(OLNode)); // 生成矩阵Q的结点 
466             if(!p)
467                 exit(0);
468             (*Q).tu++; // 非零元素数加1 
469             p->i=i; // 给结点赋值 
470             p->j=pm->j;
471             p->e=pm->e;
472             p->right=NULL;
473             pm=pm->right; // pm指针向右移 
474             if((*Q).rhead[i]==NULL) // p为该行的第1个结点 
475                 // p插在该行的表头且pq指向p(该行的最后一个结点)
476                 (*Q).rhead[i]=pq=p;  
477             else // 插在pq所指结点之后 
478             {
479                 pq->right=p; // 完成行插入 
480                 pq=pq->right; // pq指向该行的最后一个结点 
481             }
482             if((*Q).chead[p->j]==NULL) // p为该列的第1个结点
483                 // p插在该列的表头且col[p->j]指向p  
484                 (*Q).chead[p->j]=col[p->j]=p; 
485             else // 插在col[p->j]所指结点之后 
486             {
487                 col[p->j]->down=p; // 完成列插入
488                 // col[p->j]指向该列的最后一个结点 
489                 col[p->j]=col[p->j]->down;  
490             }
491         }
492         while(pn) // 将矩阵N该行的剩余元素插入矩阵Q 
493         {
494             p=(OLink)malloc(sizeof(OLNode)); // 生成矩阵Q的结点 
495             if(!p)
496                 exit(0);
497             (*Q).tu++; // 非零元素数加1 
498             p->i=i; // 给结点赋值 
499             p->j=pn->j;
500             p->e=-pn->e;
501             p->right=NULL;
502             pn=pn->right; // pm指针向右移 
503             if((*Q).rhead[i]==NULL) // p为该行的第1个结点 
504                 // p插在该行的表头且pq指向p(该行的最后一个结点)
505                 (*Q).rhead[i]=pq=p;  
506             else // 插在pq所指结点之后 
507             {
508                 pq->right=p; // 完成行插入 
509                 pq=pq->right; // pq指向该行的最后一个结点 
510             }
511             if((*Q).chead[p->j]==NULL) // p为该列的第1个结点
512                 // p插在该列的表头且col[p->j]指向p 
513                 (*Q).chead[p->j]=col[p->j]=p;  
514             else // 插在col[p->j]所指结点之后 
515             {
516                 col[p->j]->down=p; // 完成列插入
517                 // col[p->j]指向该列的最后一个结点  
518                 col[p->j]=col[p->j]->down; 
519             }
520         }
521     }
522        for(k=1;k<=(*Q).nu;k++)
523            if(col[k]) // k列有结点 
524                col[k]->down=NULL; // 令该列最后一个结点的down指针为空 
525        free(col);
526        return 1;
527 }
528 // 求稀疏矩阵乘积Q=M*N 
529 int MultSMatrix(CrossList M,CrossList N,CrossList *Q)
530 {
531     int i,j,e;
532     OLink q,p0,q0,q1,q2;
533     
534     InitSMatrix(Q);
535     (*Q).mu=M.mu;
536     (*Q).nu=N.nu;
537     (*Q).tu=0;
538     (*Q).rhead=(OLink*)malloc(((*Q).mu+1)*sizeof(OLink));
539     if(!(*Q).rhead)
540         exit(0);
541     (*Q).chead=(OLink*)malloc(((*Q).nu+1)*sizeof(OLink));
542     if(!(*Q).chead)
543         exit(0);
544     for(i=1;i<=(*Q).mu;i++) // 初始化矩阵Q的行头指针向量;各行链表为空链表 
545         (*Q).rhead[i]=NULL;
546     for(i=1;i<=(*Q).nu;i++) // 初始化矩阵Q的列头指针向量;各列链表为空链表 
547         (*Q).chead[i]=NULL;
548     for(i=1;i<=(*Q).mu;i++)
549         for(j=1;j<=(*Q).nu;j++)
550         {
551             p0=M.rhead[i];
552             q0=N.chead[j];
553             e=0;
554             while(p0&&q0)
555             {
556                 if(q0->i<p0->j)
557                     q0=q0->down; // 列指针后移 
558                 else if(q0->i>p0->j)
559                     p0=p0->right; // 行指针后移 
560                 else // q0->i==p0->j 
561                 {
562                     e+=p0->e*q0->e; // 乘积累加 
563                     q0=q0->down; // 行列指针均后移 
564                     p0=p0->right;
565                 }
566             }
567             if(e) // 值不为0 
568             {
569                 (*Q).tu++; // 非零元素数加1 
570                 q=(OLink)malloc(sizeof(OLNode)); // 生成结点 
571                 if(!q) // 生成结点失败 
572                     exit(0);
573                 q->i=i; // 给结点赋值 
574                 q->j=j;
575                 q->e=e;
576                 q->right=NULL;
577                 q->down=NULL;
578                 if(!(*Q).rhead[i]) // 行表空时插在行表头 
579                     (*Q).rhead[i]=q1=q;
580                 else // 否则插在行表尾 
581                     q1=q1->right=q;
582                 if(!(*Q).chead[j]) // 列表空时插在列表头 
583                     (*Q).chead[j]=q;
584                 else // 否则插在列表尾 
585                 {
586                     q2=(*Q).chead[j]; // q2指向j行第1个结点 
587                     while(q2->down)
588                         q2=q2->down; // q2指向j行最后1个结点 
589                     q2->down=q;
590                 }
591             }
592         }
593         return 1;
594 }
595 //  求稀疏矩阵M的转置矩阵T 
596 int TransposeSMatrix(CrossList M,CrossList *T)
597 {
598     int u,i;
599     OLink *head,p,q,r;
600     
601     if((*T).rhead)
602         DestroySMatrix(T);
603     CopySMatrix(M,T); // T=M 
604     u=(*T).mu; // 交换(*T).mu和(*T).nu 
605     (*T).mu=(*T).nu;
606     (*T).nu=u;
607     head=(*T).rhead; // 交换(*T).rhead和(*T).chead 
608     (*T).rhead=(*T).chead;
609     (*T).chead=head;
610     for(u=1;u<=(*T).mu;u++) // 对T的每一行 
611     {
612         p=(*T).rhead[u]; // p为行表头 
613         while(p) // 没到表尾,对T的每一结点 
614         {
615             q=p->down; // q指向下一个结点 
616             i=p->i; // 交换.i和.j 
617             p->i=p->j;
618             p->j=i;
619             r=p->down; // 交换.down.和right 
620             p->down=p->right;
621             p->right=r;
622             p=q; // p指向下一个结点 
623         }
624     }
625     return 1;
626 }
627 int main()
628 {
629     CrossList A,B,C;
630     InitSMatrix(&A); // CrossList类型的变量在初次使用之前必须初始化 
631     InitSMatrix(&B);
632     printf("创建矩阵A: ");
633     CreateSMatrix(&A);
634     PrintSMatrix(A);
635     printf("由矩阵A复制矩阵B: ");
636     CopySMatrix(A,&B);
637     PrintSMatrix(B);
638     DestroySMatrix(&B); // CrossList类型的变量在再次使用之前必须先销毁 
639     printf("销毁矩阵B后:\n");
640     PrintSMatrix(B);
641     printf("创建矩阵B2:(与矩阵A的行、列数相同,行、列分别为%d,%d)\n",
642         A.mu,A.nu);
643     CreateSMatrix(&B);
644     PrintSMatrix(B);
645     printf("矩阵C1(A+B): ");
646     AddSMatrix(A,B,&C);
647     PrintSMatrix(C);
648     DestroySMatrix(&C);
649     printf("矩阵C2(A-B): ");
650     SubtSMatrix(A,B,&C);
651     PrintSMatrix(C);
652     DestroySMatrix(&C);
653     printf("矩阵C3(A的转置): ");
654     TransposeSMatrix(A,&C);
655     PrintSMatrix(C);
656     DestroySMatrix(&A);
657     DestroySMatrix(&B);
658     DestroySMatrix(&C);
659     printf("创建矩阵A2: ");
660     CreateSMatrix(&A);
661     PrintSMatrix(A);
662     printf("创建矩阵B3:(行数应与矩阵A2的列数相同=%d)\n",A.nu);
663     CreateSMatrix(&B);
664     PrintSMatrix(B);
665     printf("矩阵C5(A*B): ");
666     MultSMatrix(A,B,&C);
667     PrintSMatrix(C);
668     DestroySMatrix(&A);
669     DestroySMatrix(&B);
670     DestroySMatrix(&C);
671     system("pause");
672     return 0; 
673 }

posted on 2012-08-03 08:17  mycapple  阅读(9314)  评论(0编辑  收藏

导航

统计