2. 程式人生 > >矩陣加法（基於十字連結串列）及C語言程式碼實現

矩陣加法（基於十字連結串列）及C語言程式碼實現

阿新 • • 發佈：2018-12-23
矩陣之間能夠進行加法運算的前提條件是：各矩陣的行數和列數必須相等。

在行數和列數都相等的情況下，矩陣相加的結果就是矩陣中對應位置的值相加所組成的矩陣，例如：

圖1 矩陣相加

十字連結串列法

之前所介紹的都是採用順序儲存結構儲存三元組，在類似於矩陣的加法運算中，矩陣中的資料元素變化較大（這裡的變化主要為：非0元素變為0，0變為非0元素），就需要考慮採用另一種結構——鏈式儲存結構來儲存三元組。

採用鏈式儲存結構儲存稀疏矩陣三元組的方法，稱為“十字連結串列法”。

十字連結串列法表示矩陣

例如，用十字連結串列法表示矩陣 A ，為：   圖2 矩陣用十字連結串列法表示
  由此可見，採用十字連結串列表示矩陣時，矩陣的每一行和每一個列都可以看作是一個單獨的連結串列，而之所以能夠表示矩陣，是因為行連結串列和列連結串列都分別儲存在各自的陣列中 圖 2 中：儲存行連結串列的陣列稱為 rhead 陣列
；儲存列連結串列的陣列稱為 chead 陣列。

十字連結串列中的結點

從圖2中的十字連結串列表示矩陣的例子可以看到，十字連結串列中的結點由 5 部分組成： 圖3 十字連結串列中的結點 指標域A儲存的是矩陣中結點所在列的下一個結點的地址（稱為 “down域”）；
指標域B儲存的是矩陣中該結點所在行的下一個結點的地址（稱為 “right域”）；
用結構體自定義表示為： 
typedef struct OLNode
{
    int i,j,e;                      //矩陣三元組 i 代表行 j 代表列 e 代表當前位置的資料
    struct OLNode *right,*down;     //指標域 右指標 下指標
}OLNode,*OLink;

十字連結串列的結構

使用十字連結串列表示一個完整的矩陣，在瞭解矩陣中各結點的結構外，還需要儲存矩陣的行數、列數以及非 0 元素的個數，另外，還需要將各結點連結成的連結串列儲存在陣列中。

所以，採用結構體自定義十字連結串列的結構，為：
typedef struct
{
    OLink *rhead,*chead;            //存放各行和列連結串列頭指標的陣列
    int mu,nu,tu;                   //矩陣的行數,列數和非零元的個數
}CrossList;

十字連結串列儲存矩陣三元組

由於三元組儲存的是該資料元素的行標、列標和數值，所以，通過行標和列標，就能在十字連結串列中唯一確定一個位置。

判斷方法為：在同一行中通過列標來判斷位置；在同一列中通過行標來判斷位置。

首先判斷該資料元素 A（例如三元組為：（i，j，k））所在行的具體位置：
  • 如果 A 的列標 j 值比該行第一個非 0 元素 B 的 j 值小，說明該資料元素在元素 B 的左側，這時 A 就成為了該行第一個非0元素（也適用於當該行沒有非 0 元素的情況，可以一併討論）
  • 如果 A 的列標 j 比該行第一個非 0 元素 B 的 j 值大，說明 A 在 B 的右側，這時，就需要遍歷該行連結串列，找到插入位置的前一個結點，進行插入。

對應行連結串列的位置確定之後，判斷資料元素 A 在對應列的位置：
  • 如果 A 的行標比該列第一個非 0 元素 B 的行標 i 值還小，說明 A 在 B 的上邊，這時 A 就成了該列第一個非 0 元素。（也適用於該列沒有非 0 元素的情況）
  • 反之，說明 A 在 B 的下邊，這時就需要遍歷該列連結串列，找到要插入位置的上一個資料元素，進行插入。

實現程式碼： 
//建立係數矩陣M,採用十字連結串列儲存表示
CrossList CreateMatrix_OL(CrossList M)
{
    int m,n,t;
    int i,j,e;
    OLNode *p,*q;//定義輔助變數
    scanf("%d%d%d",&m,&n,&t);  //輸入矩陣的行列及非零元的數量
    //初始化矩陣的行列及非零元的數量
    M.mu=m;
    M.nu=n;
    M.tu=t;
    if(!(M.rhead=(OLink*)malloc((m+1)*sizeof(OLink)))||!(M.chead=(OLink*)malloc((n+1)*sizeof(OLink))))
    {
        printf("初始化矩陣失敗");
        exit(0);      //初始化矩陣的行列連結串列
    }
    for(i=1;i<=m;i++)
    {
        M.rhead[i]=NULL;   //初始化行
    }
    for(j=1;j<=n;j++)
    {
        M.chead[j]=NULL;   //初始化列
    }
    for(scanf("%d%d%d",&i,&j,&e);0!=i;scanf("%d%d%d",&i,&j,&e)) //輸入三元組 直到行為0結束
    {
        if(!(p=(OLNode*)malloc(sizeof(OLNode))))
        {
            printf("初始化三元組失敗");
            exit(0);                 //動態生成p
        }
        p->i=i;
        p->j=j;
        p->e=e;                             //初始化p
        if(NULL==M.rhead[i]||M.rhead[i]->j>j)
        {
            p->right=M.rhead[i];
            M.rhead[i]=p;
        }
        else
        {
            for(q=M.rhead[i];(q->right)&&q->right->j<j;q=q->right);
            p->right=q->right;
            q->right=p;
        }
       
        if(NULL==M.chead[j]||M.chead[j]->i>i)
        {
            p->down=M.chead[j];
            M.chead[j]=p;
        }
        else
        {
            for (q=M.chead[j];(q->down)&& q->down->i<i;q=q->down);
            p->down=q->down;
            q->down=p;
        }
    }
    return M;
}

十字連結串列解決矩陣相加問題

在解決 “將矩陣 B 加到矩陣 A ” 的問題時，由於採用的是十字連結串列法儲存矩陣的三元組，所以在相加的過程中，針對矩陣 B 中每一個非 0 元素，需要判斷在矩陣 A 中相對應的位置，有三種情況：

  1. 提取到的 B 中的三元組在 A 相應位置上沒有非 0 元素，此時直接加到矩陣 A 該行連結串列的對應位置上；
  2. 提取到的 B 中三元組在 A 相應位置上有非 0 元素，且相加不為 0 ，此時只需要更改 A 中對應位置上的三元組的值即可；
  3. 提取到的 B 中三元組在 A 響應位置上有非 0 元素，但相加為 0 ，此時需要刪除矩陣 A 中對應結點。

提示：演算法中，只需要逐個提取矩陣 B 中的非 0 元素，然後判斷矩陣 A 中對應位置上是否有非 0 元素，根據不同的情況，相應作出處理。
設指標 pa 和 pb 分別表示矩陣 A 和矩陣 B 中同一行中的結點（ pb 和 pa 都是從兩矩陣的第一行的第一個非0元素開始遍歷），針對上面的三種情況，細分為 4 種處理過程（第一種情況下有兩種不同情況）：

  1. 當 pa 結點的列值 j > pb 結點的列值 j 或者 pa == NULL （說明矩陣 A 該行沒有非 0 元素），兩種情況下是一個結果，就是將 pb 結點插入到矩陣 A 中。
  2. 當 pa 結點的列值 j < pb 結點的列值 j ，說明此時 pb 指向的結點位置比較靠後，此時需要移動 pa 的位置，找到離 pb 位置最近的非 0 元素，然後在新的 pa 結點的位置後邊插入；
  3. 當 pa 的列值 j == pb 的列值 j， 且兩結點的值相加結果不為 0 ，只需要更改 pa 指向的結點的值即可；
  4. 當 pa 的列值 j == pb 的列值 j ，但是兩結點的值相加結果為 0 ，就需要從矩陣 A 的十字連結串列中刪除 pa 指向的結點。

實現程式碼： 
CrossList AddSMatrix(CrossList M,CrossList N){
    OLNode * pa,*pb;//新增的兩個用於遍歷兩個矩陣的結點
    OLink * hl=(OLink*)malloc(M.nu*sizeof(OLink));//用於儲存當前遍歷的行為止以上的區域每一個列的最後一個非0元素的位置。
    OLNode * pre=NULL;//用於指向pa指標所在位置的此行的前一個結點
    //遍歷初期，首先要對hl陣列進行初始化，指向每一列的第一個非0元素
    for (int j=1; j<=M.nu; j++) {
        hl[j]=M.chead[j];
    }
    //按照行進行遍歷
    for (int i=1; i<=M.mu; i++) {
        //遍歷每一行以前，都要pa指向矩陣M當前行的第一個非0元素；指標pb也是如此，只不過遍歷物件為矩陣N
        pa=M.rhead[i];
        pb=N.rhead[i];
        //當pb為NULL時，說明矩陣N的當前行的非0元素已經遍歷完。
        while (pb!=NULL) {
            //建立一個新的結點，每次都要複製一個pb結點，但是兩個指標域除外。（複製的目的就是排除指標域的干擾）
            OLNode * p=(OLNode*)malloc(sizeof(OLNode));
            p->i=pb->i;
            p->j=pb->j;
            p->e=pb->e;
            p->down=NULL;
            p->right=NULL;
           
            //第一種情況
            if (pa==NULL||pa->j>pb->j) {
                //如果pre為NULL，說明矩陣M此行沒有非0元素
                if (pre==NULL) {
                    M.rhead[p->i]=p;
                }else{//由於程式開始時pre肯定為NULL，所以，pre指向的是第一個p的位置，在後面的遍歷過程中，p指向的位置是逐漸向後移動的，所有，pre肯定會在p的前邊
                    pre->right=p;
                }
                p->right=pa;
                pre=p;
                //在連結好行連結串列之後，連結到對應列的列連結串列中的相應位置
                if (!M.chead[p->j]||M.chead[p->j]->i>p->i) {
                    p->down=M.chead[p->j];
                    M.chead[p->j]=p;
                }else{
                    p->down=hl[p->j]->down;
                    hl[p->j]->down=p;
                }
                //更新hl中的資料
                hl[p->j]=p;
            }else{
                //第二種情況，只需要移動pa的位置，繼續判斷pa和pb的位置，一定要有continue
                if (pa->j<pb->j) {
                    pre=pa;
                    pa=pa->right;
                    continue;
                }
                //第三、四種情況，當行標和列標都想等的情況下，需要討論兩者相加的值的問題
                if (pa->j==pb->j) {
                pa->e+=pb->e;
                //如果為0，摘除當前結點，並釋放所佔的空間
                if (pa->e==0) {
                    if (pre==NULL) {
                        M.rhead[pa->i]=pa->right;
                    }else{
                        pre->right=pa->right;
                    }
                    p=pa;
                    pa=pa->right;
                    if (M.chead[p->j]==p) {
                        M.chead[p->j]=hl[p->j]=p->down;
                    }else{
                        hl[p->j]->down=p->down;
                    }
                    free(p);
                    }
                }
            }
            pb=pb->right;
        }
    }
    //用於輸出矩陣三元組的功能函式
    display(M);
    return M;
}

完整程式碼演示

#include<stdio.h>
#include<stdlib.h>

typedef struct OLNode
{
    int i,j,e;                      //矩陣三元組i代表行 j代表列 e代表當前位置的資料
    struct OLNode *right,*down;     //指標域 右指標 下指標
}OLNode,*OLink;

typedef struct
{
    OLink *rhead,*chead;            //行和列連結串列頭指標
    int mu,nu,tu;                   //矩陣的行數,列數和非零元的個數
}CrossList;

CrossList CreateMatrix_OL(CrossList M);
CrossList AddSMatrix(CrossList M,CrossList N);

void display(CrossList M);

void main()
{
    CrossList M,N;
    printf("輸入測試矩陣M:\n");
    M=CreateMatrix_OL(M);
    printf("輸入測試矩陣N:\n");
    N=CreateMatrix_OL(N);
    M=AddSMatrix(M,N);
    printf("矩陣相加的結果為:\n");
    display(M);
}

CrossList CreateMatrix_OL(CrossList M)
{
    int m,n,t;
    int i,j,e;
    OLNode *p,*q;
    scanf("%d%d%d",&m,&n,&t);
    M.mu=m;
    M.nu=n;
    M.tu=t;
    if(!(M.rhead=(OLink*)malloc((m+1)*sizeof(OLink)))||!(M.chead=(OLink*)malloc((n+1)*sizeof(OLink))))
    {
        printf("初始化矩陣失敗");
        exit(0);
    }
    for(i=1;i<=m;i++)
    {
        M.rhead[i]=NULL;
    }
    for(j=1;j<=n;j++)
    {
        M.chead[j]=NULL;
    }
    for(scanf("%d%d%d",&i,&j,&e);0!=i;scanf("%d%d%d",&i,&j,&e))    {
        if(!(p=(OLNode*)malloc(sizeof(OLNode))))
        {
            printf("初始化三元組失敗");
            exit(0);
        }
        p->i=i;
        p->j=j;
        p->e=e;
        if(NULL==M.rhead[i]||M.rhead[i]->j>j)
        {
            p->right=M.rhead[i];
            M.rhead[i]=p;
        }
        else
        {
            for(q=M.rhead[i];(q->right)&&q->right->j<j;q=q->right);
            p->right=q->right;
            q->right=p;
        }
       
        if(NULL==M.chead[j]||M.chead[j]->i>i)
        {
            p->down=M.chead[j];
            M.chead[j]=p;
        }
        else
        {
            for (q=M.chead[j];(q->down)&& q->down->i<i;q=q->down);
            p->down=q->down;
            q->down=p;
        }
    }
    return M;
}

CrossList AddSMatrix(CrossList M,CrossList N){
    OLNode * pa,*pb;
    OLink * hl=(OLink*)malloc(M.nu*sizeof(OLink));
    OLNode * pre=NULL;
    for (int j=1; j<=M.nu; j++) {
        hl[j]=M.chead[j];
    }
    for (int i=1; i<=M.mu; i++) {
        pa=M.rhead[i];
        pb=N.rhead[i];
        while (pb!=NULL) {
            OLNode * p=(OLNode*)malloc(sizeof(OLNode));
            p->i=pb->i;
            p->j=pb->j;
            p->e=pb->e;
            p->down=NULL;
            p->right=NULL;
            if (pa==NULL||pa->j>pb->j) {
                if (pre==NULL) {
                    M.rhead[p->i]=p;
                }else{
                    pre->right=p;
                }
                p->right=pa;
                pre=p;
                if (!M.chead[p->j]||M.chead[p->j]->i>p->i) {
                    p->down=M.chead[p->j];
                    M.chead[p->j]=p;
                }else{
                    p->down=hl[p->j]->down;
                    hl[p->j]->down=p;
                }
                hl[p->j]=p;
            }else{
                if (pa->j<pb->j) {
                    pre=pa;
                    pa=pa->right;
                    continue;
                }
                if (pa->j==pb->j) {
                pa->e+=pb->e;
                if (pa->e==0) {
                    if (pre==NULL) {
                        M.rhead[pa->i]=pa->right;
                    }else{
                        pre->right=pa->right;
                    }
                    p=pa;
                    pa=pa->right;
                    if (M.chead[p->j]==p) {
                        M.chead[p->j]=hl[p->j]=p->down;
                    }else{
                        hl[p->j]->down=p->down;
                    }
                    free(p);
                    }
                }
            }
            pb=pb->right;
        }
    }
    display(M);
    return M;
}

void display(CrossList M){
    printf("輸出測試矩陣:\n");
    printf("M:\n---------------------\ni\tj\te\n---------------------\n");
    for (int i=1;i<=M.nu;i++)
    {
        if (NULL!=M.chead[i])
        {
           OLink p=M.chead[i];
            while (NULL!=p)
            {
                printf("%d\t%d\t%d\n",p->i,p->j,p->e);
                p=p->down;
            }
        }
    }

}
執行結果： 輸入測試矩陣M:
3 3 3
1 2 1
2 1 1
3 3 1
0 0 0
輸入測試矩陣N:
3 3 4
1 2 -1
1 3 1
2 3 1
3 1 1
0 0 0
矩陣相加的結果為:
輸出測試矩陣:
M:
---------------------
i j e
---------------------
2 1 1
3 1 1
1 3 1
2 3 1
3 3 1

總結

使用十字連結串列法解決稀疏矩陣的壓縮儲存的同時，在解決矩陣相加的問題中，對於某個單獨的結點來說，演算法的時間複雜度為一個常數（全部為選擇結構），演算法的整體的時間複雜度取決於兩矩陣中非0元素的個數。

相關推薦

矩陣加法（基於十字連結串列）及C語言程式碼實現

矩陣之間能夠進行加法運算的前提條件是：各矩陣的行數和列數必須相等。 在行數和列數都相等的情況下，矩陣相加的結果就是矩陣中對應位置的值相加所組成的矩陣，例如： 圖1 矩陣相加 十字連結串列法 之前所介紹的都是採用順序儲存結構儲存三元組，在類似於矩陣的加法運算中，矩陣中的資料元素變化較大（這裡的變化主

稀疏矩陣的儲存方法（3種）及C語言程式碼實現

稀疏矩陣，即含有少量非 0 元素的矩陣，如圖 1 所示：   圖 1 稀疏矩陣    該矩陣中非 0 元素的數量比較少，與其使用普通方式將矩陣中的所有資料元素一一儲存，不如只儲存非 0 元素更節省記憶體空間，拿圖 1 中矩陣來說，只需儲存元素 3、4、5 即可（此類儲存方式被稱為稀疏矩陣的壓縮儲存）。

zcmu--2201: Chip Play（dfs+十字連結串列）

2201: Chip Play Time Limit: 2 Sec  Memory Limit: 256 MB Submit: 7  Solved: 6 [Submit][Status][Web Board] Description time limit per te

資料結構之 連結串列(List)的C語言的實現

#include<stdio.h> #include<stdlib.h> #include<stdbool.h> typedef struct Node{ int data; struct Node * next; }NODE,*PNO

快速排序演算法（QSort，快排）及C語言實現

上節介紹瞭如何使用起泡排序的思想對無序表中的記錄按照一定的規則進行排序，本節再介紹一種排序演算法——快速排序演算法（Quick Sort）。 C語言中自帶函式庫中就有快速排序——qsort函式 ，包含在 <stdlib.h> 標頭檔案中。 快速排序演算法是在起泡排序的基礎上進行改進的一種演算

資料結構八：稀疏矩陣（涉及三元組，十字連結串列）

###1. 稀疏矩陣的定義 稀疏矩陣是零元素居多的矩陣，稀疏矩陣和稠密矩陣之間並沒有一個精確的界限。假設m行n列的矩陣含有t個非零元素，一般稱 δ =

建立圖的三種方法（鄰接矩陣+鄰接表+十字連結串列）

一、鄰接矩陣 採用矩陣的方式來描述圖中的連線各非連線關係，若不能連上用無窮大或者0來表示，但是如果邊很稀少，頂點很多，那麼將會有很大的浪費。同時，這個矩陣可以同時刻畫有向圖和無向圖，無向圖就是把有向圖根據對角線對稱即可。 1、思想：建立一個結構體，它包含

約瑟夫環，魯智深吃饅頭之類的問題總結c++（不用迴圈連結串列）

今天看見這一類的題，覺得用迴圈連結串列太麻煩了，就想用某一種方法來代替迴圈連結串列，總結如下。 大致題意 n 個人圍城一圈，從第一個人開始順序編號為1到n。從第1個人從1開始報數，數到3的人出圈。再由下一個人從1開始報數，數到3的人出圈，如此迴圈數下去，直到最後一個人出圈。（題意都差不多

一元多項式求和的兩種實現（陣列和連結串列）

一元多項式求和一般都是有兩種實現方式，小編下面就附上我對這兩種方式的理解和實現程式碼。 1.陣列實現。這種方式實現一元多項式加法，是把陣列下標當做一元多項式的指數，在陣列中存放係數。這種方式在實現一元多項是加法是通過遍歷陣列下標來獲取指數資訊，通過指數資訊將係數進行相加。利用陣列在實現一元多項式

P1160 佇列安排（陣列模擬連結串列）

題目描述 一個學校里老師要將班上N個同學排成一列，同學被編號為1～N，他採取如下的方法： 1.先將1號同學安排進佇列，這時佇列中只有他一個人； 2.2～N號同學依次入列，編號為i的同學入列方式為：老師指定編號為i的同學站在編號為1～i -1中某位同學（即之前已經

[二叉樹] △ 6.65 已經前序序列、中序序列 建立 二叉樹（二叉連結串列）

題目來源：嚴蔚敏《資料結構》C語言版本習題冊 6.65 【題目】6.65 已知一棵二叉樹的前序序列和中序序列分別存於兩個一維陣列中，試編寫演算法建立該二叉樹的二叉連結串列。 【答案】 // 6.65

靜態連結串列插入和刪除操作詳解（C語言程式碼實現）

本節主要講解靜態連結串列的插入和刪除操作，有關靜態連結串列的詳細講解請閱讀《靜態連結串列及C語言實現》一文。 在講解靜態連結串列的插入和刪除操作之前，我們假設有如下的靜態連結串列： 圖中，array[0] 用作備用連結串列的頭結點，array[1] 用作存放資料的連結串列的頭結點，array[0]

[LintCode] Linked List Cycle（帶環連結串列）

描述 給定一個連結串列，判斷它是否有環。 樣例 給出 -21->10->4->5, tail connects to node index 1，返回 true。 這裡解釋下，題目的意思，在英文原題中，tail connects

C 資料結構迴圈連結串列（帶環連結串列）基本操作

經典迴圈連結串列之約瑟夫問題：標號從1到n的n個人圍成一個圈，從1開始計數到m的人退出圈子，然後從退出的下一個人開始接著從1計數，數到m的人後繼續退出，最後只剩下一個人，求剩下人的編號。這便是約瑟夫問題的模型。 經典迴圈連結串列之魔術師發牌問題：魔術師手中有A、2、3……J

c語言實現二叉樹（二叉連結串列）非遞迴後序遍歷

演算法思想 因為後序遍歷是先訪問左子樹，再訪問右子樹，最後訪問根節點。當用棧實現遍歷時，必須分清返回根節點時，是從左子樹返回的還是從右子樹返回的。所以使用輔助指標r指向最近已訪問的結點。當然也可以在節點中增加一個標誌域，記錄是否已被訪問。 #include<iost

c++ stl list（環狀雙向連結串列）

1.list 　　相較於vector的連續線性空間，list就顯得複雜很多，它的好處是每次插入或刪除一個元素，就配置或釋放一個元素的空間。因此，list對空間的運用有絕對的精確，一點也不浪費。而且，對於任何位置的元素插入和元素移除，list永遠是常數時間。 　　list的節

一步一步寫演算法（之雙向連結串列）

【 宣告：版權所有，歡迎轉載，請勿用於商業用途。  聯絡信箱：feixiaoxing @163.com】     前面的部落格我們介紹了單向連結串列。那麼我們今天介紹的雙向連結串列，顧名思義，就是資料本身具備了左邊和右邊的雙向指標。雙向連結串列相比較單向連結串列，主要有下

找出二維陣列中的最長路徑（最長連結串列）

一個二維陣列 比如 1    2   3   4    5 16 17 18 19  6 15 24 25 20  7 14 23 22 21  8 13 12 11 10  9 找出其中的最長路徑，每次只能向值比自己小的方向走，且每次只能向上或者向右走。 如24為起點：2

佇列的C語言實現（通過核心連結串列）

0. 環境說明 本文的實驗環境是： win7作業系統+Keil 5 IDE. 非常適合嵌入式軟體開發 1. 打造自己的“list.h” 在微控制器程式開發中，有時候會用到佇列。能否設計一個通用的佇列呢？我想，可以把核心連結串列用起來。 以下程式碼是我

[BZOJ4516][Sdoi2016]生成魔咒（字尾陣列+連結串列）

題目 傳送門 題解 這道題還是比較好的； 要求出每一個字首本質不同的字尾的個數，那麼我們可以把原序列倒過來，然後實際上就是對於每一個字尾求與其它字尾不重複的字首個數，也即是字尾長度減去height值； 求出某一個字尾對答案的貢獻之後，他不應該停留在