_DataStructure_C_Impl:稀疏矩阵十字链表存储

#include<stdio.h>
#include<stdlib.h>
typedef int DataType;
typedef struct OLNode{
	int i,j;
	DataType e;
	struct OLNode *right,*down;
}OLNode,*OLink;
typedef struct{
	OLink *rowhead,*colhead;
	int m,n,len;
}CrossList;
//初始化稀疏矩阵
void InitMatrix(CrossList *M){
	M->rowhead=M->colhead=NULL;
	M->m=M->n=M->len=0;
}
//销毁稀疏矩阵
void DestroyMatrix(CrossList *M){
	int i;
	OLink p,q;
	for(i=0;i<M->m;i++){		//按行释放结点空间
		p=*(M->rowhead+i);
		while(p){
			q=p;
			p=p->right;
			free(q);
		}
	}
	free(M->rowhead);
	free(M->colhead);
	InitMatrix(M);
}
//使用十字链表的存储方式创建稀疏矩阵
void CreateMatrix(CrossList *M){
	int i,k;
	int m,n,num;
	OLNode *p,*q;
	if(M->rowhead)		//如果链表不空，则释放链表空间
		DestroyMatrix(M);
	printf("请输入稀疏矩阵的行数,列数,非零元素的个数: ");
	scanf("%d,%d,%d",&m,&n,&num);
	M->m=m;
	M->n=n;
	M->len=num;
	M->rowhead=(OLink*)malloc(m*sizeof(OLink));
	if(!M->rowhead)
		exit(-1);
	M->colhead=(OLink*)malloc(n*sizeof(OLink));
	if(!M->colhead)
		exit(-1);
	for(k=0;k<m;k++)		//初始化十字链表，将链表的行指针置为空
		M->rowhead[k]=NULL;
	for(k=0;k<n;k++)		//初始化十字链表，将链表的列指针置为空
		M->colhead[k]=NULL;
	printf("请按任意次序输入%d个非零元的行号、列号及元素值:\n",M->len);
	for(k=0;k<num;k++){
		p=(OLNode*)malloc(sizeof(OLNode));	 /*动态生成结点*/
		if(!p)
			exit(-1);
		printf("请输入第%d个非零元的行号(0~%d)、列号(0~%d)及元素值:",k+1,m,n);
		scanf("%d,%d,%d",&p->i,&p->j,&p->e); /*依次输入行号，列号和元素值*/
		/*-----------------------------行插入p结点-----------------------------------*/
		if(M->rowhead[p->i]==NULL||M->rowhead[p->i]->j>p->j)/*如果是第一个结点或当前元素的列号小于表头指向的一个的元素*/
		{
			p->right=M->rowhead[p->i];	
			M->rowhead[p->i]=p;
		}
		else
		{
			q=M->rowhead[p->i];
			while(q->right&&q->right->j<p->j)	/*找到要插入结点的位置*/
				q=q->right; 
			p->right=q->right;					/*将p插入到q结点之后*/
			q->right=p;
		}
		/*------------------------------列插入p结点-----------------------------------*/
		q=M->colhead[p->j];						/*将q指向待插入的链表*/
		if(!q||p->i<q->i)						/*如果p的行号小于表头指针的行号或为空表，则直接插入*/
		{
			p->down=M->colhead[p->j]; 
			M->colhead[p->j]=p;
		}
		else
		{
			while(q->down&&q->down->i<p->i)		/*如果q的行号小于p的行号，则在链表中查找插入位置*/
				q=q->down; 
			p->down=q->down;					/*将p插入到q结点之下*/
			q->down=p;
		}
	}
}
//按矩阵形式输出十字链表
void PrintMatrix(CrossList M){
	int i,j;
	OLink p;
	for(i=0;i<M.m;i++)
	{ 
		p=M.rowhead[i];				/*p指向该行的第1个非零元素*/
		for(j=0;j<M.n;j++)			/*从第一列到最后一列进行输出*/
			if(!p||p->j!=j)			/*已到该行表尾或当前结点的列值不等于当前列值，则输出0*/
				printf("%-3d",0);
			else
			{
				printf("%-3d",p->e);
				p=p->right;
			}
			printf("\n");
	}
}
//按照行序将p插入到稀疏矩阵中
void InsertMatrix(CrossList *M,OLink p){
	OLink q=M->rowhead[p->i];		/*q指向待插行表*/
	if(!q||p->j<q->j)				/*待插的行表空或p所指结点的列值小于首结点的列值，则直接插入*/
	{
		p->right=M->rowhead[p->i]; 
		M->rowhead[p->i]=p;
	}
	else
	{
		while(q->right&&q->right->j<p->j)	/*q所指不是尾结点且q的下一结点的列值小于p所指结点的列值*/
			q=q->right; 
		p->right=q->right; 
		q->right=p;
	}
	q=M->colhead[p->j];					/*q指向待插列表*/
	if(!q||p->i<q->i)					/*待插的列表空或p所指结点的行值小于首结点的行值*/
	{
		p->down=M->colhead[p->j];
		M->colhead[p->j]=p;
	}
	else
	{
		while(q->down&&q->down->i<p->i)	/*q所指不是尾结点且q的下一结点的行值小于p所指结点的行值*/
			q=q->down; 
		p->down=q->down; 
		q->down=p;
	}
	M->len++;
}
//比较两个元素值的大小。如果a>b，返回1，a=b，则返回0，a<b，则返回-1
int CompareElement(int a,int b){
	if(a<b)
		return -1;
	if(a==b)
		return 0;
	return 1;
}
//十字链表表示的两个稀疏矩阵相加运算
void AddMatrix(CrossList A,CrossList B,CrossList *C){
	int i;
	OLink pa,pb,pc;
	if(A.m!=B.m||A.n!=B.n)
	{
		printf("两个矩阵不是同类型的,不能相加\n");
		exit(-1);
	}
	/*初始化矩阵Q*/
	C->m=A.m; 
	C->n=A.n;
	C->len=0;				/*矩阵C的元素个数的初值为0*/
	/*初始化十字链表*/
	if(!(C->rowhead=(OLink*)malloc(C->m*sizeof(OLink))))	/*动态生成行表头数组*/
		exit(-1);
	if(!(C->colhead=(OLink*)malloc(C->n*sizeof(OLink))))	/*动态生成列表头数组*/
		exit(-1);
	for(i=0;i<C->m;i++)		/*初始化矩阵C的行表头指针数组，各行链表为空*/
		C->rowhead[i]=NULL;
	for(i=0;i<C->n;i++)		/*初始化矩阵C的列表头指针数组，各列链表为空*/
		C->colhead[i]=NULL;
	/*将稀疏矩阵按行的顺序相加*/
	for(i=0;i<A.m;i++)
	{
		pa=A.rowhead[i];	/*pa指向矩阵A的第i行的第1个结点*/
		pb=B.rowhead[i];	/*pb指向矩阵B的第i行的第1个结点*/
		while(pa&&pb) 
		{
			pc=(OLink)malloc(sizeof(OLNode)); /*生成新结点*/
			switch(CompareElement(pa->j,pb->j))
			{
			case -1:				/*如果A的列号小于B的列号，将矩阵A的当前元素值插入C*/
				*pc=*pa; 
				InsertMatrix(C,pc); 
				pa=pa->right; 
				break;
			case  0:				/*如果矩阵A和B的列号相等，元素值相加*/
				*pc=*pa; 
				pc->e+=pb->e;
				if(pc->e!=0)		/*如果和为非零，则将结点插入到C中*/
					InsertMatrix(C,pc); 
				else
					free(pc); 
				pa=pa->right; 
				pb=pb->right;
				break;
			case  1:				/*如果A的列号大于B的列号，将矩阵B的当前元素值插入C中*/
				*pc=*pb; 
				InsertMatrix(C,pc); 
				pb=pb->right; 
			}
		}
		while(pa)					/*如果矩阵A还有未处理完的非零元素，则将剩余元素插入C中*/
		{
			pc=(OLink)malloc(sizeof(OLNode)); 
			*pc=*pa;
			InsertMatrix(C,pc); 
			pa=pa->right; 
		}
		while(pb)					/*如果矩阵B还有未处理完的非零元素，则将剩余元素插入C中*/
		{
			pc=(OLink)malloc(sizeof(OLNode));
			*pc=*pb; 
			InsertMatrix(C,pc); 
			pb=pb->right; 
		}
	}
	if(C->len==0)					/*矩阵C的非零元素个数为零，则直接消耗C*/
		DestroyMatrix(C);
}
void main(){
	CrossList M,N,Q;
	int row,col;
	DataType value;
	OLink p;
	InitMatrix(&M);		/*初始化稀疏矩阵*/
	CreateMatrix(&M);	/*创建稀疏矩阵*/
	printf("矩阵M：\n");
	PrintMatrix(M);		/*以矩阵的形式输出稀疏矩阵*/

	InitMatrix(&N);		/*初始化稀疏矩阵*/
	CreateMatrix(&N);	/*创建稀疏矩阵*/
	printf("矩阵N：\n");
	PrintMatrix(N);	/*以矩阵的形式输出稀疏矩阵*/
	/*两个矩阵的相加*/
	AddMatrix(M,N,&Q);
	printf("两个稀疏矩阵相加结果：M+N=\n");
	PrintMatrix(Q);
	/*在矩阵M中插入一个元素*/
	printf("请输入要插入元素的行号、列号和元素值：");
	scanf("%d,%d,%d",&row,&col,&value);
	p=(OLNode*)malloc(sizeof(OLNode));
	p->i=row;
	p->j=col;
	p->e=value;
	InsertMatrix(&M,p);
	printf("插入元素后，矩阵M：\n");
	PrintMatrix(M);
	system("pause");
}

转载于:https://www.cnblogs.com/javafly/p/6037143.html