c语言版数据结构（奇迹冬瓜）-数组和广义表（十字链表存贮稀疏矩阵的行列值）

/*
   3  0  0  5
M= 0 -1  0  0  (M矩阵)
   2  0  0  0 
                 M.chead(colhead)           1          2         3        4
M.rhead(rowhead) 
1                                         1 1 3                         1 4 5

2                                                    2 2 -1

3                                         3 1 -2

4

*/

#include<stdio.h>
#include<stdlib.h>
//宏定义

#define OK 1
#define ERROR 0
#define OVERFLOW -2

typedef int Status;
typedef struct OLNode               //替换一个结构体的名字
{
	int i,j,e;                      //矩阵三元组i代表行 j代表列 e代表当前位置的数据
	struct OLNode *right,*down;     //指针域 右指针 下指针
}OLNode,*OLink;                     //结构体的新名

typedef struct 
{
	OLink *rhead,*chead;            //行和列链表头指针由CreateSMatrix分配
	int mu,nu,tu;                   //稀疏矩阵的行数,列数和非零元的个数
}CrossList;

Status CreateMatrix_OL(CrossList *M);

void main()
{
	CrossList M;
	int i;
	OLNode *p;
	CreateMatrix_OL(&M);
	printf("M:\n---------------------\ni\tj\te\n---------------------\n");
	for (i=1;i<=M.nu;i++)
	{
		if (NULL!=M.chead[i])
		{
			p=M.chead[i];
			while (NULL!=p)
			{
				printf("%d\t%d\t%d\n",p->i,p->j,p->e);
				p=p->down;
			}
		}
	}
	getchar();
	getchar();
}

Status CreateMatrix_OL(CrossList *M)  //创建系数矩阵M,采用十字链表存储表示
{
     int m,n,t;      //定义矩阵的行,列,非零元的数量
     int i,j,e;      //定义中间变量
     OLNode *p,*q;       //定义中间变量  
   //  if(M)
     //{
       //  free(M);    //如果矩阵已经存在,那么释放矩阵
     //}
     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))))
     {
        exit(OVERFLOW);      //初始化矩阵的行链表            
     }
     if(!(M->chead=(OLink*)malloc((n+1)*sizeof(OLink))))
     {
         exit(OVERFLOW);     //初始化矩阵的列链表
     }
     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))))
         {
             exit(OVERFLOW);                 //动态生成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->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=q->down);
			 p->down=q->down;
			 q->down=p;
		 }
     }
	 return OK;
}