看数据结构写代码(21) 稀疏矩阵（十字链表方式）

写完 这个例子，花费了 我不少时间，大部分时间 花费在 调试 内存问题上。

例如在销毁十字链表时，多次释放节点空间，造成 _CrtIsValidHeapPointer(pUserData) 异常。当使用malloc 分配 一个 空间时，会将这个空间的起始地址和长度 加到一个链表中去。free（p）的时候 ,会从 链表里 查找 是否 有 这个地址空间,找到了就将这个节点从链表中删除。_CrtIsValidHeapPointer(pUserData)  这个函数 正是 检查 这个空间是否 在链表里，若在，返回 true,否则返回 flase,。多次 释放节点空间，必定 造成 _CrtIsValidHeapPointer(pUserData) 异常。只要释放的 不是 分配的起始 地址 都会 报 这个异常。

还有 一个 地方，就是 使用了 释放的 空间的数据。

c/c++ 内存问题，是个 头疼的问题。

下面 进入 正题：

稀疏矩阵 的 十字链表 方式，是 给 所有的行 和 列 都 当成 一个 链表 来处理。第 i 行 j列的 非0 节点，既在 第 i行的链表上，又在 第 j列的 链表上，所以 叫 十字链表。

结构图如下：

下面 上代码

欢迎指出代码不足

// CrossList.cpp : 定义控制台应用程序的入口点。
//稀疏矩阵的十字链表实现

#include "stdafx.h"
#include <stdlib.h>

typedef int ElementType;
enum E_State
{
	E_State_Error = 0,
	E_State_Ok = 1,
};

struct MatrixNode
{
	int row;
	int col;
	ElementType data;
	MatrixNode * rightNext;
	MatrixNode * downNext;
};

MatrixNode * makeNode(int row,int col,ElementType data){
	MatrixNode * newNode = (MatrixNode *) malloc(sizeof(MatrixNode));
	if (newNode != NULL)
	{
		newNode->row = row;
		newNode->col = col;
		newNode->data = data;
		newNode->rightNext = NULL;
		newNode->downNext = NULL;
	}
	return newNode;
}
//十字链表
struct CrossList
{
	MatrixNode ** rowHead;
	MatrixNode ** colHead;
	int rowNum;
	int colNum;
	int totalNum;
};

E_State listInit(CrossList * list,int row,int col){
	list->rowHead = (MatrixNode**)malloc(sizeof(MatrixNode*) * row);
	list->colHead = (MatrixNode**)malloc(sizeof(MatrixNode*) * col);
	if (list->rowHead && list->colHead)
	{
		list->rowNum = row;
		list->colNum = col;
		list->totalNum = 0;
		//建立头指针节点
		for (int i = 0; i < row; i++)
		{
			list->rowHead[i] = makeNode(-1,-1,-1);
			if (list->rowHead[i] == NULL)
			{
				return E_State_Error;
			}
		}
		for (int i = 0; i < col; i++)
		{
			list->colHead[i] = makeNode(-1,-1,-1);
			if (list->colHead[i] == NULL)
			{
				return E_State_Error;
			}
		}
		return E_State_Ok;
	}
	return E_State_Error;
}

//销毁十字链表
void listDestory(CrossList * list){
	//销毁链表节点
	for (int i = 0; i < list->rowNum; i++)
	{
		MatrixNode * head = list->rowHead[i];
		MatrixNode * next = head->rightNext;
		while (next != NULL)
		{
			MatrixNode * freeNode = next;
			next = next->rightNext;
			free(freeNode);
		}
		//别忘了销毁头节点
		free(head);
	}
	
	for (int i = 0; i < list->colNum; i++)
	{
		MatrixNode * head = list->colHead[i];
		free(head);
		/*销毁了两遍，呵呵
		MatrixNode * next = head->downNext;
		while (next != NULL)
		{
			MatrixNode * freeNode = next;
			next = next->downNext;
			free(freeNode);
		}*/
		
	}
	free(list->colHead);
	free(list->rowHead);
	list->colHead = NULL;
	list->rowHead = NULL;
	list->rowNum = 0;
	list->colNum = 0;
	list->totalNum = 0;
}

//在 row 行 col 列 插入 一个 data 元素(从 0行，0列 开始）
E_State listInsert(CrossList * list,ElementType data,int row,int col){
	if (row < 0 || row >= list->rowNum || col >= list->colNum || col < 0)
	{
		return E_State_Error;
	}
	MatrixNode * newNode = makeNode(row,col,data);
	if (newNode != NULL)
	{
		//加入行链表
		MatrixNode * pre = list->rowHead[row];
		MatrixNode * next = pre->rightNext;
		while (next != NULL)//寻找 第一个列值 小于 col 的节点
		{
			if (next->col > col)
			{
				break;
			}
			pre = next;
			next = next ->rightNext;
		}
		newNode->rightNext = pre->rightNext;
		pre->rightNext = newNode;
		//加到列链表
		pre = list->colHead[col];
		next = pre->downNext;
		while (next != NULL)//寻找 第一个列值 小于 col 的节点
		{
			if (next->row > row)
			{
				break;
			}
			pre = next;
			next = next ->downNext;
		}
		newNode->downNext = pre->downNext;
		pre->downNext = newNode;
		list->totalNum ++;
		return E_State_Ok;
	}
	return E_State_Error;
}

//row ,col 从 0行 0 列 开始
E_State listDelete(CrossList * list,int row,int col,ElementType * delData){
	if (row >= list->rowNum || row < 0 || col >= list->colNum || col <0)
	{
		return E_State_Error;
	}
	*delData = 0;
	//查找行链表
	MatrixNode * pre = list->rowHead[row];
	MatrixNode * next = pre->rightNext;
	while (next != NULL)
	{
		if (next->col == col)
		{
			pre->rightNext = next->rightNext;
			break;
		}
		else if(next->col > col)// 删除的节点 值域为0
		{
			return E_State_Ok;
		}
		pre = next;
		next = next->rightNext;
	}
	//查找列链表
	pre = list->colHead[col];
	next = pre->downNext;
	while (next != NULL)
	{
		if (next->row == row)
		{
			pre->downNext = next->downNext;
			*delData = next->data;
			list->totalNum --;
			//在查找完了 列链表之后 才能 释放 空间，要不 会内存 错误.
			free(next);
			break;
		}
		else if(next->row > row)// 删除的节点 值域为0
		{
			return E_State_Ok;
		}
		pre = next;
		next = next->downNext;
	}
	return E_State_Ok;
}

//list1 = list1 + list2
E_State listAdd(CrossList * list1,CrossList list2){
	if (list1->rowNum != list2.rowNum || list1->colNum != list2.colNum)
	{
		return E_State_Error;
	}
	for (int row = 0; row < list1->rowNum; row++)
	{
		MatrixNode * next1 = list1->rowHead[row]->rightNext;
		MatrixNode * next2 = list2.rowHead[row]->rightNext;
		while (next1 && next2)
		{
			int col1 = next1->col;
			int col2 = next2->col;
			if (col1 == col2)//元素 同行 同列
			{
				ElementType sum = next1->data + next2->data;
				if (sum == 0)//相加为0
				{
					ElementType del;
					next1 = next1->rightNext;//跟下一句颠倒过来，会有内存错误
					listDelete(list1,row,col1,&del);
				}
				else//相加不为0
				{
					next1->data = sum;
					next1 = next1->rightNext;
				}
				next2 = next2->rightNext;
			}
			else if(col1 < col2)//元素1 小于 元素2 的 列
			{
				next1 = next1->rightNext;
			}
			else//元素1 大于 元素2的列，插入元素2
			{
				listInsert(list1,next2->data,row,col2);
				next2 = next2->rightNext;
			}
		}
		//插入剩余的 next2 元素
		while (next2 != NULL )
		{
			listInsert(list1,next2->data,row,next2->col);
			next2 = next2->rightNext;
		}
	}
	return E_State_Ok;
}

// list1 = list1 - list2
E_State listSub(CrossList * list1,CrossList list2){
	if (list1->rowNum != list2.rowNum || list1->colNum != list2.colNum)
	{
		return E_State_Error;
	}
	for (int i = 0; i < list2.rowNum; i++)
	{
		MatrixNode * next = list2.rowHead[i]->rightNext;
		while (next != NULL)
		{
			next->data = -next->data;
			next = next->rightNext;
		}
	}
	return listAdd(list1,list2);
}

//list3 = list1 * list2
E_State listMult(CrossList list1, CrossList list2,CrossList * list3){
	if (list1.colNum != list2.rowNum)
	{
		return E_State_Error;
	}
	listInit(list3,list1.rowNum,list2.colNum);
	for (int row = 0; row < list1.rowNum; row++)
	{
		for (int col = 0; col < list2.colNum; col++)
		{
			MatrixNode * nextCol2 = list2.colHead[col]->downNext;
			ElementType mul = 0;
			while (nextCol2)
			{
				MatrixNode * nextRow1 = list1.rowHead[row]->rightNext;
				while (nextRow1)
				{
					if (nextRow1->col == nextCol2->row)
					{
						mul += nextRow1 -> data * nextCol2 ->data;
					}
					nextRow1 = nextRow1->rightNext;
				}
				nextCol2 = nextCol2->downNext;
			}
			if (mul != 0)
			{
				listInsert(list3,mul,row,col);
			}
		}
	}
	return E_State_Ok;
}

void listTraverse(CrossList list){
	printf("--------------------遍历开始-----------------\n");
	for (int i = 0; i < list.rowNum; i++)
	{
		MatrixNode * next = list.rowHead[i]->rightNext;
		while (next != NULL)
		{
			printf("%d行 %d列 ： %d\n",next->row+1,next->col+1,next->data);
			next = next->rightNext;
		}
	}
	printf("--------------------遍历结束------------------\n");
}

int initData[5][10] = {
	{1,0,0,0,0,0,0,0,0,0},
	{0,0,2,0,0,0,0,0,5,0},
	{0,0,0,3,0,0,0,0,0,0},
	{0,2,0,0,0,0,0,0,0,0},
	{1,0,0,0,0,0,0,0,0,9},
};

int initAddData[5][10]= {
	{1,0,0,0,3,0,0,0,0,0},
	{0,0,2,0,4,0,0,0,5,0},
	{0,0,0,3,0,0,0,0,0,0},
	{0,2,0,0,2,0,0,0,0,0},
	{1,0,0,0,1,0,0,0,0,9},
};

int initData2 [10][2] = {
	{1,0},
	{0,0},
	{0,0},
	{0,0},
	{0,0},
	{0,6},
	{0,0},
	{0,0},
	{5,0},
	{0,0},
};

int _tmain(int argc, _TCHAR* argv[])
{
	//初始化数据
	printf("--------------------矩阵1------------\n");
	CrossList list1;
	listInit(&list1,5,10);
	for (int i = 0; i < 5; i++)
	{
		for (int j = 0; j < 10; j++)
		{
			int data = initData[i][j];
			if (data != 0)
			{
				listInsert(&list1,data,i,j);
			}
		}
	}
	listTraverse(list1);
	printf("--------------------矩阵2------------\n");
	CrossList list2;
	listInit(&list2,5,10);
	for (int i = 0; i < 5; i++)
	{
		for (int j = 0; j < 10; j++)
		{
			int data = initAddData[i][j];
			if (data != 0)
			{
				listInsert(&list2,data,i,j);
			}
		}
	}
	listTraverse(list2);
	printf("--------------------矩阵1 = 矩阵1 + 矩阵2------------\n");
	listAdd(&list1,list2);
	listTraverse(list1);
	printf("--------------------矩阵1 = 矩阵1 - 矩阵2------------\n");
	listSub(&list1,list2);
	listTraverse(list1);
	printf("--------------------矩阵3------------\n");
	CrossList list3;
	listInit(&list3,10,2);
	for (int i = 0; i < 10; i++)
	{
		for (int j = 0; j < 2; j++)
		{
			int data = initData2[i][j];
			if (data != 0)
			{
				listInsert(&list3,data,i,j);
			}
		}
	}
	listTraverse(list3);
	printf("--------------------矩阵4 = 矩阵1 * 矩阵3------------\n");
	CrossList list4;
	listMult(list1,list3,&list4);
	listTraverse(list4);
	//释放内存空间
	listDestory(&list1);
	listDestory(&list2);
	listDestory(&list3);
	listDestory(&list4);
	return 0;
}

运行截图：