[数据结构]第五章-数组和广义表(读书笔记1)

最新推荐文章于 2022-11-16 08:51:07 发布

进击的横打

最新推荐文章于 2022-11-16 08:51:07 发布

阅读量1.6k

点赞数

分类专栏：数据结构

本文链接：https://blog.csdn.net/Last_Impression/article/details/8665349

版权

数据结构专栏收录该内容

22 篇文章 1 订阅

订阅专栏

第五章-数组和广义表

数组和广义表可以看成是线性表在下述含义上的扩展：表中的数据元素本身也是一个数据结构。

5.1 数组的定义
当n=1时，n维数组就退化为定长的线性表。反之，n维数组也可以看成是线性表的推广。数组一旦被定义，它的维数和维界就不再改变。
typedef ElemType Array2[m][n]；
等价于
typedef ElemType Array1[n]；
typedef Array1 Array2[m]；

5.2 数组的顺序表示和实现
对于数组，一旦规定了它的维数和各维的长度，便可为它分配存储空间。下面是顺序存储表示和实现。

/*标准头文件，提供宏va_start,va_arg和va_end*/
/*用于存取变长参数表*/
#include <stdarg.h>	
/*假设数组维数的最大值为8*/
#define MAX_ARRAY_DIM 8 
typedef int ElemType;

typedef struct{
	/*数组元素基址，由InitArray分配*/
	ElemType *base;
	/*数组维数*/
	int dim;
	/*数组维界基址，由InitArray分配*/
	int *bounds;
	/*数组映像函数常量基址，由InitArray分配*/
	int *constants;
}Array;

Status InitArray(Array *A, int dim,...)
{/*若维数dim和各维长度合法，则构造相应的数组A，并返回OK*/
	int elemtotal;
	int i;
	va_list ap;
	if ( dim < 1 || dim > MAX_ARRAY_DIM ){
		return ERROR;
	}
	A->dim = dim;
	A->bounds = (int *)malloc(dim * sizeof(int));
	if (!A->bounds){
		exit(OVERFLOW);
	}
	/*若各维长度合法，则存入A.bounds，并求出A的元素总数elemtotal*/
	elemtotal = 1;
	/*ap为va_list类型，是存放变长参数表信息的数组*/
	va_start(ap,dim);
	for (i = 0; i < dim; ++i){
		A->bounds[i] = va_arg(ap,int);
		if (A->bounds[i] < 0){
			return UNDERFLOW;
		}
		elemtotal += A->bounds[i];
	}
	va_end(ap);
	A->base = (ElemType*)malloc(elemtotal * sizeof(ElemType));
	if (!A->base){
		exit(OVERFLOW);
	}
	/* 求映像函数的常数c，并存入A.constants[i-1],i=1,...dim */
	A->constants = (int *)malloc(dim * sizeof(int));
	if(!A->constants){
		exit(OVERFLOW);
	}
	/*数组最后一维肯定是1，数组的增减以元素大小为单位*/
	A->constants[dim - 1] = 1;
	for(i = dim - 2; i >= 0; --i){
		A->constants[i] = A->bounds[i+1] * A->constants[i+1];
	}
	return OK;
}
Status DestroyArray(Array *A)
{/*销毁数组A*/
	if(!A->base){
		return ERROR;
	}
	free(A->base);
	A->base = NULL;
	if(!A->bounds){
		return ERROR;
	}
	free(A->bounds);
	A->bounds = NULL;
	if(!A->constants){
		return ERROR;
	}
	free(A->constants);
	A->constants = NULL;
	return OK;
}
Status Locate(Array A,va_list ap,int &off)
{/*若ap指示的各下标值合法，则求出该元素在A中相对地址off*/
	int i;
	int ind;
	off = 0;
	for (i = 0;i < A.dim; i++){
		ind = va_arg(ap, int);
		if (ind < 0 || ind >= A.bounds[i]){
			return OVERFLOW;
		}
		off += A.constants[i] * ind;
	}
	return OK;
}
Status Value(Array *A, ElemType *e,...)
{
	Status result;
	int off;
	va_list ap;
	va_start(ap,e);
	if ((result = Locate(*A,ap,off)) <= 0){
		return result;
	}
	*e = *(A->base + off);
	return OK;
}
Status Assign(Array *A, ElemType e,...)
{/*A是n维数组，e为元素变量，随后是n个下标值*/
 /*若下标不超界，则将e的值赋给所指定的A的元素，并返回OK*/
	Status result;
	int off;
	va_list ap;
	va_start(ap,e);
	if ((result = Locate(*A,ap,off)) <= 0){
		return result;
	}
	*(A->base + off) = e;
	return OK;
}
int _tmain(int argc, _TCHAR* argv[])
{
   Array A;
   int i,j,k,*p,dim = 3,bound1 = 3,bound2 = 4,bound3 = 2; /* a[3][4][2]数组 */
   ElemType e,*p1;
   InitArray(&A,dim,bound1,bound2,bound3); /* 构造3＊4＊2的3维数组A */
   p=A.bounds;
   printf("A.bounds=");
   for(i=0;i<dim;i++) /* 顺序输出A.bounds */
     printf("%d ",*(p+i));
   p=A.constants;
   printf("\nA.constants=");
   for(i=0;i<dim;i++) /* 顺序输出A.constants */
     printf("%d ",*(p+i));
   printf("\n%d页%d行%d列矩阵元素如下:\n",bound1,bound2,bound3);
   for(i=0;i<bound1;i++)
   {
     for(j=0;j<bound2;j++)
     {
       for(k=0;k<bound3;k++)
       {
         Assign(&A,i*100+j*10+k,i,j,k); /* 将i*100+j*10+k赋值给A[i][j][k] */
         Value(&A,&e,i,j,k); /* 将A[i][j][k]的值赋给e */
         printf("A[%d][%d][%d]=%2d ",i,j,k,e); /* 输出A[i][j][k] */
       }
       printf("\n");
     }
     printf("\n");
   }
   p1=A.base;
   printf("A.base=\n");
   for(i=0;i<bound1*bound2*bound3;i++) /* 顺序输出A.base */
   {
     printf("%4d",*(p1+i));
     if(i%(bound2*bound3)==bound2*bound3-1)
       printf("\n");
   }
   DestroyArray(&A);
	return 0;
}

5.3 矩阵的压缩存储

矩阵的压缩存储：为多个值相同的元只分配一个存储空间，对零元不分配空间。假若值相同的元素或者零元素在矩阵中的分布有一定规律，则我们称此类矩阵为特殊矩阵；反之称为稀疏矩阵。

5.3.1 特殊矩阵
对于对称矩阵，我们可以为每一对对称元分配一个存储空间，则可将n2个元压缩存储到n(n+1)/2个元的空间中。
所谓下(上)三角矩阵是指矩阵的上(下)三角(不包括对角线)中的元均为常数c或零的n阶矩阵。
对这类矩阵，我们也可按某个原则(或以行为主，或以对角线的顺序)将其压缩存储到一维数组上。
5.3.2 稀疏矩阵
其非零元较零元少，且分布没有一定规律，我们称之为稀疏矩阵。按照压缩存储的概念，只存储稀疏矩阵的非零元。因此除了存储非零元的值之外，还必须同时记下它所在行和列的位置(i,j)。

typedef int ElemType;
#define MAXSIZE 100 /* 非零元个数的最大值 */
/* 三元组顺序表：稀疏矩阵的一种压缩存储算法 */
typedef struct {
	int i,j;/* 行下标,列下标 */
	ElemType e;/* 非零元素值 */
}Triple;

typedef struct {
	Triple data[MAXSIZE + 1];	/* 非零元三元组表,data[0]未用 */
	int mu,nu,tu;				/* 矩阵的行数、列数和非零元个数 */
}TSMatrix;

Status CreateSMatrix(TSMatrix *M)
{ /* 创建稀疏矩阵M */
	int i;
	int m,n,e;
	Status k;
	
	printf("请输入矩阵的行数,列数,非零元素数：");	
	scanf("%d,%d,%d",&(*M).mu,&(*M).nu,&(*M).tu);
	(*M).data[0].i = 0; /* 为以下比较顺序做准备 */
	for(i = 1; i <= (*M).tu; i++){
		do{
			printf("请按行序顺序输入第%d个非零元素所在的行(1～%d),列(1～%d),元素值：",i,(*M).mu,(*M).nu);
			scanf("%d,%d,%d", &m, &n, &e);
			k = 0;
			if(m < 1 || m > (*M).mu || n < 1 || n > (*M).nu){ /* 行或列超出范围 */
				k = 1;
			}
			if(m <= (*M).data[i-1].i && n <= (*M).data[i-1].j){ /* 行或列的顺序有错 */
				k = 1;
			}
		}while(k);
		(*M).data[i].i = m;
		(*M).data[i].j = n;
		(*M).data[i].e = e;
	}
	return OK;
}

void DestroySMatrix(TSMatrix *M)
{ /* 销毁稀疏矩阵M */
	(*M).mu = 0;
	(*M).nu = 0;
	(*M).tu = 0;
}
void PrintSMatrix(TSMatrix M)
{ /* 输出稀疏矩阵M */
	int i;
	printf("%d行%d列%d个非零元素。\n", M.mu, M.nu, M.tu);
	printf("行  列  元素值\n");
	for(i = 1; i <= M.tu; i++){
		printf("%2d%4d%8d\n", M.data[i].i, M.data[i].j, M.data[i].e);
	}
}
Status CopySMatrix(TSMatrix M,TSMatrix *T)
{ /* 由稀疏矩阵M复制得到T */
	(*T) = M;
	return OK;
}
/*
 1)将矩阵的行列值相互交换
 2)将每个三元组中的i和j相互调换
 3)重排三元组之间的次序便可实现矩阵的转置
*/
Status TransposeSMatrix(TSMatrix M, TSMatrix *T)
{ /* 求稀疏矩阵M的转置矩阵T。算法5.1 */
	int q;
	int col,p;
	(*T).mu = M.mu;/*矩阵的行*/
	(*T).nu = M.nu;/*矩阵的列*/
	(*T).tu = M.tu;/*非零元个数*/
	/*算法的时间复杂度为O(nu*tu)，即和M的列数及非零元的个数的乘积成正比*/
	if ((*T).tu != 0){
		q = 1;
		for(col = 1; col <= M.nu; col++){
			for(p = 1; p <= M.tu; p++){
				if (M.data[p].j == col){ /*列的下标==列下标*/
					T->data[q].i = M.data[p].j;
					T->data[q].j = M.data[p].i;
					T->data[q].e = M.data[p].e;
					++q;
 				}
			}		
		}
	}
	return OK;
}
int comp(int c1,int c2) /* 另加 */
{ /* AddSMatrix函数要用到 */
	int i;
	if(c1 < c2){
		i = 1;
	}
	else if(c1 == c2){
		i = 0;
	}
	else{
		i = -1;
	}
	return i;
}
Status AddSMatrix(TSMatrix M, TSMatrix N, TSMatrix *Q)
{ /* 求稀疏矩阵的和Q=M+N */
	Triple *Mp,*Me,*Np,*Ne,*Qh,*Qe;
	if(M.mu != N.mu || M.nu != N.nu){
		return ERROR;
	}
	(*Q).mu = M.mu;
	(*Q).nu = M.nu;
	Mp = &M.data[1]; /* Mp的初值指向矩阵M的非零元素首地址 */
	Np = &N.data[1]; /* Np的初值指向矩阵N的非零元素首地址 */
	Me = &M.data[M.tu]; /* Me指向矩阵M的非零元素尾地址 */
	Ne = &N.data[N.tu]; /* Ne指向矩阵N的非零元素尾地址 */
	Qh = Qe = (*Q).data; /* Qh、Qe的初值指向矩阵Q的非零元素首地址的前一地址 */
	while( Mp <= Me && Np <= Ne ){
		Qe++;
		switch(comp(Mp->i, Np->i)){
			case  1: 
				*Qe = *Mp;
				Mp++;
				break;
			case  0: 
				switch(comp(Mp->j,Np->j)){ /* M、N矩阵当前非零元素的行相等,继续比较列 */
				case  1: 
					*Qe = *Mp;
					Mp++;
					break;
				case  0: 
					*Qe = *Mp;
					Qe->e += Np->e;
					if(!Qe->e){ /* 元素值为0，不存入压缩矩阵 */
						Qe--;
					}
					Mp++;
					Np++;
					break;
				case -1: 
					*Qe = *Np;
					Np++;
					break;
                }//switch
                break;
		case -1: 
			*Qe = *Np;
			Np++;
			break;
		}//switch
	}
	if(Mp > Me){ /* 矩阵M的元素全部处理完毕 */
		while(Np <= Ne){
			Qe++;
			*Qe = *Np;
			Np++;
		}
	}
	if(Np > Ne){ /* 矩阵N的元素全部处理完毕 */
		while(Mp <= Me){
			Qe++;
			*Qe = *Mp;
			Mp++;
		}
	}
	(*Q).tu = Qe - Qh; /* 矩阵Q的非零元素个数 */
	return OK;
}

Status SubtSMatrix(TSMatrix M, TSMatrix N, TSMatrix *Q)
{ /* 求稀疏矩阵的差Q=M-N */
   int i;
   for(i = 1; i <= N.tu; i++){
	   N.data[i].e *= -1;
   }
   AddSMatrix(M,N,Q);
   return OK;
}

Status MultSMatrix(TSMatrix M, TSMatrix N, TSMatrix *Q)
{ /* 求稀疏矩阵的乘积Q=M*N */
	int i,j,h=M.mu,l=N.nu,Qn=0;
	/* h,l分别为矩阵Q的行、列值,Qn为矩阵Q的非零元素个数，初值为0 */
	ElemType *Qe;
	if(M.nu != N.mu){
		return ERROR;
	}
	(*Q).mu = M.mu;	/*行数*/
	(*Q).nu = N.nu;	/*列数*/	
	Qe = (ElemType *)malloc(h * l * sizeof(ElemType)); /* Qe为矩阵Q的临时数组 */
	/* 矩阵Q的第i行j列的元素值存于*(Qe+(i-1)*l+j-1)中，初值为0 */
	for(i = 0; i < h * l; i++){
		*(Qe + i) = 0; /* 赋初值0 */
	}
	for(i = 1; i <= M.tu; i++){ /* 矩阵元素相乘，结果累加到Qe */
		for(j = 1; j <= N.tu; j++){
			if(M.data[i].j == N.data[j].i){
				*(Qe + (M.data[i].i - 1) * l + N.data[j].j - 1) += M.data[i].e * N.data[j].e;
			}
		}
	}
	for(i = 1; i <= M.mu; i++){
		for(j = 1;j <= N.nu; j++){
			if(*(Qe+(i-1)*l+j-1)!=0){
				Qn++;
			}
			(*Q).data[Qn].e = *(Qe + (i - 1) * l + j - 1);
			(*Q).data[Qn].i = i;
			(*Q).data[Qn].j = j;
		}
	}
	free(Qe);
	(*Q).tu = Qn;
	return OK;
}
int _tmain(int argc, _TCHAR* argv[])
{
	TSMatrix A,B,C;
	printf("创建矩阵A: ");
	CreateSMatrix(&A);
	PrintSMatrix(A);
	printf("由矩阵A复制矩阵B: ");
	CopySMatrix(A,&B);
	PrintSMatrix(B);
	DestroySMatrix(&B);
	printf("销毁矩阵B后:\n");
	PrintSMatrix(B);
	printf("创建矩阵B2:(与矩阵A的行、列数相同，行、列分别为%d,%d)\n",A.mu,A.nu);
	CreateSMatrix(&B);
	PrintSMatrix(B);
	printf("矩阵C1(A+B): ");
	AddSMatrix(A,B,&C);
	PrintSMatrix(C);
	DestroySMatrix(&C);
	printf("矩阵C2(A-B): ");
	SubtSMatrix(A,B,&C);
	PrintSMatrix(C);
	DestroySMatrix(&C);
	printf("矩阵C3(A的转置): ");
	TransposeSMatrix(A,&C);
	PrintSMatrix(C);
	DestroySMatrix(&A);
	DestroySMatrix(&B);
	DestroySMatrix(&C);
	printf("创建矩阵A2: ");
	CreateSMatrix(&A);
	PrintSMatrix(A);
	printf("创建矩阵B3:(行数应与矩阵A2的列数相同=%d)\n",A.nu);
	CreateSMatrix(&B);
	PrintSMatrix(B);
	printf("矩阵C5(A*B): ");
	MultSMatrix(A,B,&C);
	PrintSMatrix(C);
	DestroySMatrix(&A);
	DestroySMatrix(&B);
	DestroySMatrix(&C);
	return 0;
}

进击的横打

关注

0
点赞
踩
5

收藏

觉得还不错? 一键收藏
打赏
0
评论
[数据结构]第五章-数组和广义表(读书笔记1)

第五章-数组和广义表数组和广义表可以看成是线性表在下述含义上的扩展：表中的数据元素本身也是一个数据结构。5.1 数组的定义当n=1时，n维数组就退化为定长的线性表。反之，n维数组也可以看成是线性表的推广。数组一旦被定义，它的维数和维界就不再改变。typedef ElemType Array2[m][n]；等价于typedef ElemType Array1[n]；typ
复制链接

扫一扫