数据结构学习（六）

矩阵的存储方式

特殊矩阵：对称矩阵，上（下）三角矩阵，只存储一半的数据

可以将对称矩阵的数据存放在数组中

数组下标k与矩阵位置i，j的关系如下

若存储对称矩阵的上半区

若存储对称矩阵的下半区

同时，可以通过数据中元素的位置，获取到对应的值。

上（下）三角矩阵的存储方式与对称矩阵相同

稀疏矩阵

不存0，存其他数据的值，位置，同时记录下矩阵的size

                                                              图 5 稀疏矩阵示意图

需要存储以下信息：

（1，1，1），（3，3，1），（5，2，3），以及矩阵的行数3和列数3。

稀疏矩阵的压缩存储，数据结构提供有 3 种具体实现方式：

三元组顺序表

//三元组顺序表
typedef struct triple
{
	int i;
	int j;
	int data;
};

#define max_size 20
typedef struct tmatrix
{
	triple t[max_size];
	int i, j, num;
};

初始化

void inittriple(tmatrix& tm)
{
	tm.i = 3;
	tm.j = 3;
	tm.num = 3;

	tm.t[0].i = 1;
	tm.t[0].j = 1;
	tm.t[0].data = 1;

	tm.t[1].i = 2;
	tm.t[1].j = 2;
	tm.t[1].data = 4;

	tm.t[2].i = 3;
	tm.t[2].j = 1;
	tm.t[2].data = 6;
}

打印

void printtriple(tmatrix tm)
{
	for (int i = 0; i < tm.i; i++)
	{
		for (int j = 0; j < tm.j; j++)
		{
			int flag = 0;
			for (int k = 0; k < tm.num; k++)
			{
				if (i + 1 == tm.t[k].i && j + 1 == tm.t[k].j)
				{
					cout << tm.t[k].data << " ";
					flag = 1;
				}
			}
			if (flag == 0)
			{
				cout << "0 ";
			}
		}
		cout << endl;
	}
}

行逻辑链接顺序表

typedef struct Triple
{
    int i,j;//行，列
    int e;//元素值
};

#define MAXSIZE 12500
#define MAXRC 100

typedef struct RLSMatrix
{
    Triple  data[MAXSIZE+1];
    int rpos[MAXRC+1];//每行第一个非零元素在data数组中的位置
    int mu,nu,tu;//行数，列数，元素个数
};

与三元组顺序表相似，多了一个记录每行第一个非0元素在data中的位置，减少遍历的次数。

十字链表

链表中包含行数，列数，值，行指针，列指针（指向下一个非0节点）

//十字链表法
typedef struct tennode
{
	struct tennode* h;
	struct tennode* l;
	int i, j, val;
};

typedef struct tenhead
{
	tennode* headh;
	tennode* headl;
	int i, j, num;
};

初始化

tenhead* inittenhead(int i1,int j1,int num)
{
	tenhead* th = (tenhead*)malloc(sizeof(tenhead));

	th->headh = (tennode*)malloc(sizeof(tennode));
	th->headl = (tennode*)malloc(sizeof(tennode));

	th->i = i1;
	th->j = j1;
	th->num = num;

	tennode* htemp = th->headh;
	for (int i = 0; i < i1; i++)
	{
		tennode* tn = (tennode*)malloc(sizeof(tennode));
		tn->i = i + 1;
		tn->j = 0;
		tn->h = NULL;
		tn->l = NULL;

		htemp->h = tn;
		htemp = tn;
	}

	tennode* ltemp = th->headl;
	for (int j = 0; j < j1; j++)
	{
		tennode* tn = (tennode*)malloc(sizeof(tennode));
		tn->j = j + 1;
		tn->i = 0;
		tn->h = NULL;
		tn->l = NULL;

		ltemp->l = tn;
		ltemp = tn;
	}

	return th;
}

插入元素

void insertnode(tenhead* th, int i1, int j1, int val)
{
	tennode* tn = (tennode*)malloc(sizeof(tennode));
	tn->i = i1;
	tn->j = j1;
	tn->val = val;
	tn->h = NULL;
	tn->l = NULL;
	int lflag = 0;
	int hflag = 0;

	tennode* htemp = th->headh;
	for (int i = 0; i < i1; i++)
	{
		htemp = htemp->h;
	}
	if (htemp->l == NULL)
	{
		htemp->l = tn;
	}
	else
	{
		while (htemp->l != NULL)
		{
			tennode* htemp1 = htemp;
			htemp = htemp->l;
			if (htemp->j > j1)
			{
				htemp1->l = tn;
				tn->l = htemp;
				lflag = 1;
				break;
			}
		}
		if (lflag == 0)
		{
			htemp->l = tn;
		}

	}


	tennode* ltemp = th->headl;
	for (int j = 0; j < j1; j++)
	{
		ltemp = ltemp->l;
	}
	if (ltemp->h == NULL)
	{
		ltemp->h = tn;
	}
	else
	{
		while (ltemp->h != NULL)
		{
			tennode* ltemp1 = ltemp;
			ltemp = ltemp->h;
			if (ltemp->i > i1)
			{
				ltemp1->h = tn;
				tn->h = ltemp;
				hflag = 1;
				break;
			}
		}
		if (hflag == 0)
		{
			ltemp->h = tn;
		}

	}

}

打印

void printtenhead(tenhead* th)
{
	tennode* htemp = th->headh;
	for (int i = 1; i <= th->i; i++)
	{
		htemp = htemp->h;
		tennode* htemp1 = htemp;
		int num = 0;
		while (htemp1->l != NULL)
		{
			htemp1 = htemp1->l;
			num++;
			while (num != htemp1->j)
			{
				cout << "0 ";
				num++;
			}
			if (num == htemp1->j)
			{
				cout << htemp1->val<<" ";
			}
		}
		for (int i = num + 1; i <= th->j; i++)
		{
			cout << "0 ";
		}
		cout << endl;
	}
}