采用十字链表存储的稀疏矩阵

题目描述

当矩阵的非零元个数和位置在操作过程中变化较大时，就不宜采用顺序存储的结构来表示三元组的线性表了。因此，在这种情况下，采用链式存储结构表示三元组更为恰当。十字链表就是能够实现这样功能的一种数据结构。

在十字链表中，每个非零元可以用一个包含5个域的结点表示。其中i、j和e这3个域分别表示该非零元所在的行、列和非零元的值，向右域right用来链接同一行中下一个非零元，而向下域down用来链接同一列中下一个非零元。同一行的非零元通过right域链接成一个线性链表，同一列的非零元通过down域链接成一个线性链表。每个非零元既是某个行链表中的一个结点，又是某个列链表中的一个结点，整个矩阵通过这样的结构形成了一个十字交叉的链表。

稀疏矩阵的十字链表类型可以描述如下：

下面是建立稀疏矩阵十字链表的算法描述：

给出一个稀疏矩阵，请将其存储到一个十字链表中，并将存储完毕的矩阵输出。

输入

输入的第一行是两个整数r和c（r<200, c<200, r*c <= 12500），分别表示一个包含很多0的稀疏矩阵的行数和列数。接下来有r行，每行有c个整数，用空格隔开，表示稀疏矩阵的各个元素。

输出

输出读入的矩阵。输出共有r行，每行有c个整数，每个整数后输出一个空格。请注意行尾输出换行。

样例输入

5 6
0 18 0 0 0 0
0 0 67 0 0 0
0 0 0 0 0 41
0 0 47 62 0 0
0 0 0 0 0 35

样例输出

0 18 0 0 0 0 
0 0 67 0 0 0 
0 0 0 0 0 41 
0 0 47 62 0 0 
0 0 0 0 0 35 

提示

*** 提示已隐藏，点击此处可显示 ***

收起提示[-]

提示：
对于m行n列且有t个非零元的稀疏矩阵，算法5.4的执行时间为O(t×s)，其中s=max(m,n)。这是由于每建立一个非零元结点时，都需要通过遍历查询它所在的行表和列表中的插入位置。这是因为我们采用的算法实际上对于非零元的输入先后次序并没有要求，而如果能够保证非零元是按照以行序为主序的顺序输入的话，则可以将十字链表的建立过程修改为O(t)复杂度的。
总结：
采用十字链表存储的稀疏矩阵适用于矩阵中的非零元个数和位置经常发生变化或变化较大的情况，链式结构使得数据的插入、修改和删除变得十分容易。

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

#define   TRUE                    1
#define   FALSE                    0
#define   OK                    1
#define   ERROR                    0
#define   OVERFLOW                -2
#define   INFEASIBLE            -1

typedef int ElemType;

typedef struct  OLNode
{
    int i,j;
    ElemType e;
    struct OLNode  *right, *down;
}OLNode, *OLink;
typedef struct
{
    OLink *rhead, *chead;
    int mu,nu,tu;
}CrossList;
int CreateSMatrix_OL(CrossList *M)
{
    if(M)  free(M);
    int m,n,t=0;
    scanf("%d%d",&m,&n);
    M->mu=m; M->nu=n;
    if(!(M->rhead=(OLink *)malloc((m+1)*sizeof(OLink))))   return ERROR;
    if(!(M->chead=(OLink *)malloc((n+1)*sizeof(OLink))))   return ERROR;
    int a,b;
    for (a=1;a<=m;a++)   M->rhead[a]=NULL;
    for (b=1;b<=n;b++)   M->chead[b]=NULL;
    int i,j,e;
    for(i=1;i<=m;i++)
    {
        for(j=1;j<=n;j++)
        {
            scanf("%d",&e);
            if(e!=0)
            {
                t++;
                OLNode *p,*q;
                if(!(p=(OLNode *)malloc(sizeof(OLNode))))   return ERROR;
                p->i=i; p->j=j; p->e=e; p->down=NULL; p->right=NULL;
                if(M->rhead[i]==NULL||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(M->chead[j]==NULL||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;
                }
            }
        }
    }
    M->tu=t;
    return OK;
}
void print(CrossList M)
{
    int p,q;
    OLNode *pTemp;
    for(p=1;p<=M.mu;p++)
    {
        pTemp=M.rhead[p];
        for(q=1;q<=M.nu;q++)
        {
            if(pTemp!=NULL&&pTemp->j==q)
            {
                printf("%d ",pTemp->e);
                pTemp=pTemp->right;
            }
            else
                printf("0 ");
        }
        printf("\n");
    }
    return ;
}
int main()
{
    CrossList M;
    CreateSMatrix_OL(&M);
    print(M);
    return 0;
}