数据结构基础（2）数组和广义表_广义表中原子的深度-优快云博客

本文链接：https://blog.youkuaiyun.com/captaincoke/article/details/105249107

本文深入探讨了稀疏矩阵的压缩存储方法，包括三元组表示及快速转置、矩阵加法和乘法算法。同时，介绍了广义表的结构特点和存储表示方法，如头尾指针的链表结构。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

GOAL

这方面需要掌握的内容比较少，也比较简单，概念理解清楚就没问题，细节还是要看看书的。

Content

数组存储表示方法
数组是多维结构，但存储空间是一维结构

在这里插入图片描述

地址计算
二维数组：
数组的大小为mn：(i=0-m-1,j=0-n-1)
loc(i,j)=loc(0,0)+L(in+j)
n维数组：
数组大小为b1b2*…bn:(ji=0-bi-1)
loc(j1,j2…jn)=loc(0,0…0)+L(j1b2b3…bn+j2b3*…bn+…+jn-1bn+jn)

稀疏矩阵的压缩存储

上三角矩阵的变换公式
k=i*(i-1)/2+j（i>=1,j>=1)
下三角矩阵的变换公式
k=i*(i-1)/2+j-(N+1-i)+1

随机稀疏矩阵的压缩存储方法：三元组顺序表

快速转置与矩阵加法

#include "stdio.h"
#include "stdlib.h"
#include"string.h"
#define N 30
typedef struct mytripple//定义三元组
{
	int i,j,data;
}TR;

typedef struct mymatrix//定义稀疏矩阵的数据结构
{
	TR T[N];//三元组数组
	int mu,nu,tu;//mu表示行数,nu表示列数,tu表示非零元的个数
}MA;

void showmatrix(MA *A);//显示稀疏矩阵
MA reversema(MA *A);//对稀疏矩阵进行快速转置，并返回逆置结果：O(tu+mu)
void init(MA *A,MA *B);//对稀疏矩阵初始化，赋初始值
MA addition(MA *A,MA *B);//将两个稀疏矩阵相加，并返回结果O(A->tu+B->tu)
void main()
{
	MA A,B;
	init(&A,&B);//对两个稀疏矩阵赋值
	printf("the original matrix A is:\n");
	showmatrix(&A);//显示稀疏矩阵A	
	printf("the original matrix B is:\n");
	showmatrix(&B);//显示稀疏矩阵B	
	A=addition(&A,&B);//将A与B相加并将结果返回给A
	printf("the result of addition is:\n");
	showmatrix(&A);	//显示相加的结果
	A=reversema(&A);//将矩阵A逆置
	printf("after reverse,the matrix is:\n");
	showmatrix(&A);//显示逆置后的结果
}

void showmatrix(MA *A)
{
	int i,j,k;//i表示行号，j表示列号，k表示三元组中非零元的序号
	for(i=1,k=1;i<=A->mu;i++)
	{
		for(j=1;j<=A->nu;j++)
		{
			if(A->T[k].i==i&&A->T[k].j==j)
			{
				printf("%4d",A->T[k].data);
				k++;
			}
			else
				printf("   0");			
		}
		printf("\n");
	}
	printf("\n");
}



MA reversema(MA *A)//快速转置
{
	MA B;B.mu=A->nu;B.nu=A->mu;B.tu=A->tu;
	int *Cpot=(int*)malloc(sizeof(int)*(A->nu+1));
	int *num=(int*)malloc(sizeof(int)*(A->nu+1));
	memset(num,0,sizeof(int)*(A->nu+1));
	int i,tempind;
	Cpot[1]=1;
	for(i=1;i<=A->tu;i++) num[A->T[i].j]++;
	for(i=2;i<=A->nu;i++) Cpot[i]=Cpot[i-1]+num[i-1];
	for(i=1;i<=A->tu;i++) 
	{	
		tempind=Cpot[A->T[i].j]++;
		B.T[tempind].i=A->T[i].j;
		B.T[tempind].j=A->T[i].i;
		B.T[tempind].data=A->T[i].data;
	}
	return B;
}

MA addition(MA *A,MA *B)
{

	MA C;
	int i,j,k,sum;
	C.mu=A->mu;
	C.nu=A->nu;
	for(i=1,j=1,k=1;i<=A->tu&&j<=B->tu;)
	{
		if(A->T[i].i<B->T[j].i)
		{
			C.T[k]=A->T[i];
			k++;
			i++;
		}
		else if(A->T[i].i>B->T[j].i)
		{
			C.T[k]=B->T[j];
			k++;
			j++;
		}
		else if(A->T[i].j>B->T[j].j)
		{
			C.T[k]=B->T[j];
			k++;
			j++;
		}
		else if(A->T[i].j<B->T[j].j)
		{
			C.T[k]=A->T[i];
			k++;
			i++;
		}
		else
		{	
			sum=A->T[i].data+B->T[j].data;
			if(sum)
			{
				C.T[k]=B->T[j];
				C.T[k].data=sum;
				k++;
				j++;
				i++;
			}
			else
			{

				i++;
				j++;
			}
		}
	}
	while(i<=A->tu) 
	{
		C.T[k]=A->T[i];
		k++;
		i++;
	}
	while(j<=B->tu)
	{
		C.T[k]=B->T[j];
		k++;
		j++;
	}
	C.tu=k-1;
	printf("k=%d",k);
	return C;

}
void init(MA *A,MA *B)
{
	A->mu=3;
	A->nu=4;
	A->tu=4;
	A->T[1].data=3;
	A->T[1].i=1;
	A->T[1].j=2;
	A->T[2].data=-1;
	A->T[2].i=2;
	A->T[2].j=2;
	A->T[3].data=12;
	A->T[3].i=2;
	A->T[3].j=4;
	A->T[4].data=9;
	A->T[4].i=3;
	A->T[4].j=1;
///
	B->mu=3;
	B->nu=4;
	B->tu=5;
	B->T[1].data=4;
	B->T[1].i=1;
	B->T[1].j=4;
	B->T[2].data=1;
	B->T[2].i=2;
	B->T[2].j=2;
	B->T[3].data=5;
	B->T[3].i=2;
	B->T[3].j=3;
	B->T[4].data=2;
	B->T[4].i=3;
	B->T[4].j=1;
	B->T[5].data=-6;
	B->T[5].i=3;
	B->T[5].j=2;

}

加行逻辑链接的三元组表示方法

原三元组结构若要存取元素需要遍历，不是很方便，因此在原三元组结构上加上cpot，即没有货第一个元素在三元组表中所在的位置，这样在进行元素的存取和矩阵乘法时避免遍历大量的0。
例子：矩阵乘法

#include "stdio.h"
#include "stdlib.h"
#include"string.h"
#define N 30
typedef struct mytripple//定义三元组
{
	int i,j,data;
}TR;

typedef struct mymatrix//定义稀疏矩阵的数据结构
{
	TR T[N];//三元组数组
	int rpos[N];//每行第一个非零元所在序号 
	int mu,nu,tu;//mu表示行数,nu表示列数,tu表示非零元的个数
}MA;

void showmatrix(MA *A);//显示稀疏矩阵
void init(MA *A,MA *B);//对稀疏矩阵初始化，赋初始值
MA multiply(MA *A,MA *B);//稀疏矩阵相乘 
main()
{
	MA A,B,C; 
	init(&A,&B);//对两个稀疏矩阵赋值
	printf("the original matrix A is:\n");
	showmatrix(&A);//显示稀疏矩阵A	
	printf("the original matrix B is:\n");
	showmatrix(&B);//显示稀疏矩阵B	
	C=multiply(&A,&B);
	showmatrix(&C);

}

void showmatrix(MA *A)
{
	int i,j,k;//i表示行号，j表示列号，k表示三元组中非零元的序号
	for(i=1,k=1;i<=A->mu;i++)
	{
		for(j=1;j<=A->nu;j++)
		{
			if(A->T[k].i==i&&A->T[k].j==j)
			{
				printf("%4d",A->T[k].data);
				k++;
			}
			else
				printf("   0");			
		}
		printf("\n");
	}
	printf("\n");
}
MA multiply(MA *A,MA *B)//稀疏矩阵相乘
{
	MA C;C.mu=A->mu;C.nu=B->nu;C.tu=0;
	if (A->nu!=B->mu) exit(1);
	if (A->tu*B->tu==0)
	return C;
	int r1,c1,r2,c2,i,j,k;
	int e1,e2;
	int ctemp[N];
	for(r1=1;r1<=A->mu;r1++)
	{	C.rpos[r1]=C.tu+1;
		memset(ctemp,0,sizeof(int)*N);
		if(r1<A->mu) e1=A->rpos[r1+1];
		else e1=A->tu+1;
		for(i=A->rpos[r1];i<e1;i++)
		{
			r2=A->T[i].j;
			if(r2<B->mu) e2=B->rpos[r2+1];
			else e2=B->tu+1;
			for(j=B->rpos[r2];j<e2;j++)
			{
				c1=B->T[j].j;
				ctemp[c1]+=A->T[i].data*B->T[j].data;
			}
		}
		for(k=1;k<B->mu;k++)
		{
			if(ctemp[k])
			{
				C.tu++;
				C.T[C.tu].i=r1;
				C.T[C.tu].j=k;
				C.T[C.tu].data=ctemp[k];
			}
		}
	}
	return C;
	 
}
void init(MA *A,MA *B)
{
	A->mu=3;
	A->nu=4;
	A->tu=4;
	A->T[1].data=3;
	A->T[1].i=1;
	A->T[1].j=1;
	A->T[2].data=5;
	A->T[2].i=1;
	A->T[2].j=4;
	A->T[3].data=-1;
	A->T[3].i=2;
	A->T[3].j=2;
	A->T[4].data=2;
	A->T[4].i=3;
	A->T[4].j=1;
	A->rpos[1]=1;
	A->rpos[2]=3;
	A->rpos[3]=4;
///
	B->mu=4;
	B->nu=2;
	B->tu=4;
	B->T[1].data=2;
	B->T[1].i=1;
	B->T[1].j=2;
	B->T[2].data=1;
	B->T[2].i=2;
	B->T[2].j=1;
	B->T[3].data=-2;
	B->T[3].i=3;
	B->T[3].j=1;
	B->T[4].data=4;
	B->T[4].i=3;
	B->T[4].j=2;
	B->rpos[1]=1;
	B->rpos[2]=2;
	B->rpos[3]=3;
	B->rpos[4]=5;
}

广义表的结构特点与存储表示方法

在这里插入图片描述
结构特点：
1.广义表中的元素有相对次序
2.长度定义为最外层包含的元素个数
3.深度所含括号的重数（原子的深度为0，空表的深度为1）
4.广义表可以共享
5.广义表可以是递归的表（递归表E=(a,E),长度为2，深度为无穷）
表示方法：（头尾指针的链表结构）
1.表节点：标志域，指示表头的指针域，指示表尾的指针域
2.原子节点：标志域，值域
在这里插入图片描述