稀疏矩陣的十字鏈表存儲表示和實現

  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 }