十字链表实现稀疏矩阵，包含十二大功能

最新推荐文章于 2024-04-04 15:34:37 发布
最新推荐文章于 2024-04-04 15:34:37 发布
阅读量2.9k 收藏 71
点赞数 10
文章标签： c语言 数据结构 链表 hash 矩阵
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46335449/article/details/121415507
版权

题目：

  1. 十字链表实现稀疏矩阵

1．问题描述

用十字链表存储和表示稀疏矩阵，并实现如下功能

2．基本要求

  1. 初始化：创建十字链表并从文件中读取稀疏矩阵数据（文件数据可以是三元组结构）；
  2. 在十字链表上设置坐标为（i，j）的位置值为value；
  3. 获取坐标为（i，j）的位置的值；
  4. 插入一项、删除某项的值；
  5. 输出十字链表表示的稀疏矩阵；
  6. 实现两个稀疏矩阵的加法、减法、乘法的功能，结果保存到新的十字链表中；
  7. 实现把十字链表表示的稀疏矩阵存入文件；
  8. 可以用菜单选择所有功能，设计良好的操作界面；
  9. 在需求分析阶段完成未尽功能需求，适当扩充功能（例如矩阵转置、求最值等）。

实现：

技术难点1：uthash存储十字链表矩阵，给每个矩阵进行命名，以名字作为key，十字链表作为value,实现相对自动化的功能；（需要自己在github上找到相关资源）

技术难点2：十字链表矩阵的插入函数是整个代码的核心，需要对十字链表的存储结构比较熟悉

技术难点3：十字链表矩阵的相加函数，针对两个矩阵不同对应的情况进行相加

代码前面的声明：

 

#include<iostream>
#include<cstdlib>
#include<iomanip>
#include"uthash.h" 
using namespace std;

/*                 稀疏矩阵的十字链表存储                                       */

typedef struct OLNode
{
    int row;                                                    			//非零元素的行下标
    int col;    															//非零元素的列下标
    int elem;    															//非零元素值
    struct OLNode *right;   												//右节点
    struct OLNode *down;   												    //下节点

}OLNode, *OLink;

typedef struct 
{
    OLink *rhead;   														//行指针链表
    OLink *chead;   														//列指针链表
    int rowSum;     														//矩阵的行数
    int ColSum;     														//矩阵的列数
    int NumSum;     														//矩阵的非零元素个数
}CrossList; 


/*                 uthash哈希表的结构体声明                                      */

struct HashCross{															//哈希表
    char name[10];															//矩阵名称  key
    CrossList crosslist;													//十字链表结构体  value
    UT_hash_handle hh;												
}HashCross;

/*                          全局hash表，存储矩阵                                */

struct HashCross *cross = NULL;											
 
/*   ************************************************************************** */

/*                          函数声明                                            */


void menu();						                    					//主菜单
void menu1(); 						               							//初始化部分
void menu2();						                						//基础操作部分
void menu3();  						                						//进阶操作部分   
void InitSMatrix(CrossList &M);				  								//初始化矩阵
void CreateMatrix(CrossList &M);											//创建矩阵	
void PrintSMatrix(CrossList M);												//输出矩阵
void InsertElem(OLink &newnode,CrossList &M);								//插入元素到矩阵M中
void changeValue(CrossList &M);												//寻找矩阵M中的某个值
void findValue(CrossList &M);												//查找矩阵中的某个值
void deleteValue(CrossList &M);												//删除矩阵中的某个值
void AddMatrix(CrossList &M,CrossList &N,CrossList &out);					//两个矩阵的相加
void SubtractMatrix(CrossList &M,CrossList &N,CrossList &out);				//两个矩阵的相减
void MultiplyMatrix(CrossList &M,CrossList &N,CrossList &out);				//两个矩阵的相乘
void TransposeSMatrix(CrossList &M, CrossList &out);						//矩阵的转置 
void findMaxOrMin(CrossList &M);										    //矩阵求最值 
void CopySMatrix(CrossList &M, CrossList &out);								//复制矩阵 
void ReadFromFile(CrossList &M);											//从文件中读取矩阵 
void WriteToFile(CrossList &M);												//把矩阵写入文件 
CrossList HashFind(char *name);												//哈希查找函数(没有该矩阵，手动创建)
CrossList HashFind2( char *name);											//哈希查找函数(没有该矩阵，文件读取创建)
CrossList getCrossList();													//控制台获取矩阵名称(没有该矩阵，手动创建)



/*   ************************************************************************** */

具体每个功能的函数：

/*                        实现功能的函数                                        */



/*                        1. 主菜单                                             */
void menu()    
{
    int c=0;
	printf("--------------------------------------------------------------------------------\n");
	printf("******************<-----欢迎使用十字链表存储的稀疏矩阵进行操作----->*****************\n\n");
	printf("\t\t\t     1.*--<矩阵初始化>--*\n\n");
	printf("\t\t\t     2.*--<矩阵基本操作（插入、删除、查找）>--*\n\n");
	printf("\t\t\t     3.*--<矩阵进阶操作（四则运算、求逆、求转置、求最值等）>--*\n\n");
	printf("\t\t\t     4.*--<退出本程序>--*\n\n");
	printf("\n\n********************************************************************************\n");
	printf("--------------------------------------------------------------------------------\n");
	printf("*请输入相应功能的编号:");
	do
	{
		cin >> c;
		if(c<1||c>4)
			printf("*无该选项!请重新输入:");
	}while(c<1||c>4);
     switch(c)
     {
    	case 1:menu1();break;
	    case 2:menu2();break;
	   	case 3:menu3();break;
    	case 4:exit(0);break;
      }
}

/*   ************************************************************************** */

/*                        2.初始化菜单                                          */ 

void menu1()   
{
	int c=0;
	while(c != 1){
		printf("--------------------------------------------------------------------------------\n");
		printf("******************<-----欢迎来到矩阵初始化菜单----->*****************\n\n");
		printf("\t\t\t     1.*--<返回主菜单>--*\n\n");
		printf("\t\t\t     2.*--<手动输入矩阵>--*\n\n");
		printf("\t\t\t     3.*--<从文件中读取矩阵>--*\n\n");
		printf("\t\t\t     4.*--<退出本程序>--*\n\n");
		printf("\n\n********************************************************************************\n");
		printf("--------------------------------------------------------------------------------\n");
		printf("*请输入相应功能的编号:");
		do
		{
			cin >> c;
			if(c<1||c>4)
				printf("*无该选项!请重新输入:");
		}while(c<1||c>4);
	     switch(c)
	     {
	    	case 1:
				menu();
				break;
		    case 2:{
                getCrossList();
				break;
			}

	    	case 3:{
	    		CrossList M;
		    	printf("请输入需要操作的矩阵名称:（长度小于10）\n");
	            char name[10];
	            cin >> name;
				M = HashFind2(name); 
				break;
			}
	    	case 4:exit(0);
				break;
	      }
	  }
}

/*   ************************************************************************** */

/*                        3.  矩阵基本操作菜单                                  */

void menu2()     
{   
	int c=0;
    while(c != 1){
		printf("--------------------------------------------------------------------------------\n");
		printf("******************<-----欢迎来到矩阵基本操作菜单----->*****************\n\n");
		printf("\t\t\t     1.*--<返回主菜单>--*\n\n");
		printf("\t\t\t     2.*--<查看矩阵下标的值>--*\n\n");
		printf("\t\t\t     3.*--<删除矩阵下标的值>--*\n\n");
		printf("\t\t\t     4.*--<增加矩阵下标的值>--*\n\n");
		printf("\t\t\t     5.*--<退出本程序>--*\n\n");
		printf("\n\n********************************************************************************\n");
		printf("--------------------------------------------------------------------------------\n");
		printf("*请输入相应功能的编号:");
		do
		{
			cin >> c;
			if(c<1||c>5)
				printf("*无该选项!请重新输入:");
		}while(c<1||c>5);
	     switch(c)
	     {
	    	case 1:menu();break;
		    case 2:{
		    	CrossList M;
		    	M = getCrossList(); 
				findValue(M);
				break;
			}

	    	case 3:{
	    		CrossList M;
	    		M = getCrossList();
				deleteValue(M);
				break;
			}

	    	case 4:{
	    		CrossList M;
	    		M = getCrossList();
				changeValue(M);
				break;
			}		

	    	case 5:exit(0);break;
	      }
	}
}

/*   ************************************************************************** */

/*                        4.  矩阵进阶操作菜单                                  */

void menu3()     
{
    int c=0;
    while(c != 1){
		printf("--------------------------------------------------------------------------------\n");
		printf("******************<-----欢迎来到矩阵进阶操作菜单----->*****************\n\n");
		printf("\t\t\t     1.*--<返回主菜单>--*\n\n");
		printf("\t\t\t     2.*--<求稀疏矩阵的加法>--*\n\n");
		printf("\t\t\t     3.*--<求稀疏矩阵的减法>--*\n\n");
		printf("\t\t\t     4.*--<求稀疏矩阵的乘法>--*\n\n");
		printf("\t\t\t     5.*--<求稀疏矩阵的转置>--*\n\n");
		printf("\t\t\t     6.*--<输出稀疏矩阵>--*\n\n");
		printf("\t\t\t     7.*--<求稀疏矩阵的最值>--*\n\n");
		printf("\t\t\t     8.*--<将稀疏矩阵存入文件>--*\n\n");
		printf("\t\t\t     9.*--<退出本程序>--*\n\n");
		printf("\n\n********************************************************************************\n");
		printf("--------------------------------------------------------------------------------\n");
		printf("*请输入相应功能的编号:");
		do
		{
			cin >> c;
			if(c<1||c>9)
				printf("无该选项!请重新输入:");
		}while(c<1||c>9);
	     switch(c)
	     {
	    	case 1:
				menu(); break;
		    case 2:{
		    	CrossList M,N,out;
	    		M = getCrossList();
	    		N = getCrossList();
				AddMatrix(M,N,out);
				break;
			}
				
	    	case 3:{
	    		CrossList M,N,out;
	    		M = getCrossList();
	    		N = getCrossList();
				SubtractMatrix(M,N,out);
				break;
			}
				
	    	case 4:{
	    		CrossList M,N,out;
	    		M = getCrossList();
	    		N = getCrossList();
				MultiplyMatrix(M,N,out);
				break;
			}
				
	    	case 5:{
	    		CrossList M,out;
	    		M = getCrossList();
				TransposeSMatrix(M,out);
				break;
			}
				
	    	case 6:{
	    		CrossList M;
	    		M = getCrossList();
	    		PrintSMatrix(M);	
				break;
				} 
				
	    	case 7:{
	    		CrossList M;
	    		M = getCrossList();
				findMaxOrMin(M);
				break;
				}
	    	case 8:{
				CrossList M;
	    		M = getCrossList();
	    		WriteToFile(M);
				break;
			} 
	    	case 9:exit(0);break;
	      }
	  }
}
/*   ************************************************************************** */


/*                        5.  初始化稀疏矩阵                                    */

void InitSMatrix(CrossList &M){
    M.rhead = (OLink *)malloc((M.rowSum+1)*sizeof(OLink));
    M.chead = (OLink *)malloc((M.ColSum+1)*sizeof(OLink));
    
    //将所有结点赋为空值
    for(int i = 1; i<=M.rowSum; i++)
    {
        M.rhead[i]=NULL;
    }
    for(int i = 1; i <= M.ColSum; i++)
    {
        M.chead[i]=NULL;
    }
}

/*   ************************************************************************** */


/*                        6.  创建稀疏矩阵                                      */
void CreateMatrix(CrossList &M){
    int rowSum,ColSum,NumSum;
    int row, col, elem;
    cout << "请输入创建的稀疏矩阵的行数、列数、非0元素个数：\n" << endl;
	cin >> rowSum >> ColSum >> NumSum;
    M.rowSum = rowSum;
    M.ColSum = ColSum;
    M.NumSum = NumSum;
    //初始化矩阵
    InitSMatrix(M);
    //对矩阵进行赋值
    cout << "请按任意次序输入" << M.NumSum <<"个非零元的行 列 元素值:" << endl;

    for(int i = 1; i <= NumSum; i++){
    	cin >> row; 
		cin >> col;
		cin >> elem;
        OLink newNode = (OLink)malloc(sizeof(OLNode));
        newNode -> row = row;
        newNode -> col = col;
        newNode -> elem = elem;
        InsertElem(newNode,M);
    }
    cout << "创建成功！创建的矩阵为：\n" << endl;
//    printf("创建成功！创建的矩阵为：\n");
    PrintSMatrix(M); 
    
}

/*   ************************************************************************** */

/*                        7.  插入结点值                                        */

void InsertElem(OLink &newnode, CrossList &M){
    //将非零元素结点插入矩阵中
    OLink rowNode = M.rhead[newnode->row];
    //行的插入
    if (rowNode == NULL || rowNode -> col > newnode -> col) // 插在该行的第一个结点处 
		{
			newnode->right = rowNode;
			M.rhead[newnode->row] = newnode;
		}
	else 
		{
            //寻找插的位置的前一个结点
			for (; !(rowNode->col < newnode->col && (rowNode->right == NULL||rowNode -> right -> col > newnode->col)); rowNode = rowNode->right);
			newnode->right = rowNode->right; //完成行插入 
			rowNode->right = newnode;
		}

    //列的插入
    OLink colNode = M.chead[newnode -> col];
    if (colNode == NULL || colNode -> row > newnode -> row) // 插在该行的第一个结点处 
		{
			newnode->down = colNode;
			M.chead[newnode->col] = newnode;
		}
	else 
		{
            //寻找插的位置的前一个结点
			for (; !(colNode -> row < newnode->row && (colNode -> down == NULL || colNode -> down -> row > newnode->row)); colNode = colNode->down);
			newnode->down = colNode->down; //完成列插入 
			colNode->down = newnode;
		}
}

/*   ************************************************************************** */

/*                        8.  输出矩阵                                          */

void PrintSMatrix(CrossList M){
    //初始条件: 稀疏矩阵M存在
    int i, j;
	for (i = 1; i <= M.rowSum; i++)
	{ // 从第1行到最后1行
		OLink p = M.rhead[i]; // p指向该行的第1个非零元素
		for (j = 1; j <= M.ColSum; j++) // 从第1列到最后1列
			if (!p || p->col != j) // 已到该行表尾或当前结点的列值不等于当前列值
				printf("%-5d", 0); // 输出0
			else
			{
				printf("%-5d", p->elem);
				p = p->right;
			}
		printf("\n");
	}
}

/*   ************************************************************************** */

/*                        9. 修改矩阵中某个元素的值(如果没有就增加）            */

void changeValue(CrossList &M){
	//如果不存在对应下标的值，则直接插入新的值
	int row;
	int col;
	int elem;
	cout << "请输入需要修改的矩阵的行 列 元素值:\n" << endl;
	cin >> row >> col >> elem;
	OLink rowNode = M.rhead[row];
	OLink newnode = (OLink)malloc(sizeof(OLNode));
    newnode->row = row;
    newnode->col = col;
    newnode->elem = elem;

	if(rowNode == NULL || rowNode -> col > col){
		//如果行链表的头结点为空或者是当前修改的结点的列值大于头结点的列值，直接插入
		cout << "插入新值！\n" << endl;
//		printf("插入新值！\n");
		InsertElem(newnode,M);
	}
	else{
		OLink nextNode = rowNode;
		//头结点不为空，进行判断
		while(nextNode){
			if(nextNode -> col == col){
				nextNode -> elem = elem;
				cout << "修改成功！\n" << endl;
//				printf("修改成功！\n");
				break;
			}
			else if(nextNode -> col > col){
				cout << "插入新值！\n" << endl;
//				printf("插入新值！\n");
				InsertElem(newnode,M);
				break;
			}
			else{
				nextNode = nextNode -> right;
			}
		}
		//头结点为空时，直接插入
		if(nextNode == NULL){
			cout << "插入新值！\n" << endl;
//			printf("插入新值！\n");
			InsertElem(newnode,M);
		}
	}
	cout << "修改后的矩阵为:\n" << endl;
//	printf("修改后的矩阵为:\n");
	PrintSMatrix(M);
}

/*   ************************************************************************** */

/*                        10. 查找矩阵中某个元素的值                            */

void findValue(CrossList &M){
	int row;
	int col;
	cout << "请输入需要查找的矩阵的对应的行 列 下标值（如：10 10）:\n" << endl;
    cin >> row >> col;
	OLink rowNode = M.rhead[row];
	if(rowNode == NULL || rowNode -> col > col){
		//如果行链表的头结点为空或者是当前修改的结点的列值大于头结点的列值，该元素的值为0
		cout << "下标为：(" << row << "," << col << ")值elem = 0\n" << endl;
	}
	else{
		OLink nextNode = rowNode;
		//头结点不为空，进行判断
		while(nextNode){
			if(nextNode -> col == col){
				int val = nextNode -> elem;
				cout << "下标为：(" << row << "," << col << ")值elem =" << val << endl;
				break;
			}
			else if(nextNode -> col > col){
				cout << "下标为：(" << row << "," << col << ")值elem = 0\n" << endl;
				break;
			}
			else{
				nextNode = nextNode -> right;
			}
		}
		//头结点为空时，值为0 
		if(nextNode == NULL){
			cout << "下标为：(" << row << "," << col << ")值elem = 0\n" << endl;
		}
	}

}

/*   ************************************************************************** */

/*                        11. 删除矩阵中某个元素的值                            */

void deleteValue(CrossList &M){
	int row;
	int col;
	cout << "请输入1需要删除的矩阵的对应的行 列 的下标值（如：10 10）:\n" << endl;
	scanf("%d %d", &row, &col);

	//行指针的删除
	OLink rowNode = M.rhead[row];
	if(rowNode == NULL || rowNode -> col > col){
		//如果行链表的头结点为空或者是当前的结点的列值大于头结点的列值，该元素的值为0
		cout << "该下标对应的值为0，无需删除\n" << endl;
		return;
	}
	else{
		OLink p = NULL, q = NULL;
		p = rowNode;
		while(rowNode){
			if(rowNode -> col == col){
				if(p == rowNode){
					M.rhead[row] = p -> right;
				}
				else{
					q ->right = p -> right;
				}
				break;
			}
			else if(rowNode -> col > col){
				return;
			}
			else{
				q = p;
				p = p -> right;
			}
		}
	}

	//列指针的删除
	OLink ColNode = M.chead[col];
	if(ColNode == NULL || ColNode -> row > row){
		cout << "该下标对应的值为0，无需删除\n" << endl;
		return;
	}
	else{
		OLink p = NULL, q = NULL;
		p = ColNode;
		while(ColNode){
			if(ColNode -> col == col){
				if(p == ColNode){
					M.chead[col] = p -> down;
				}
				else{
					q -> down = p -> down;
				}
				break;
			}
			else if(ColNode -> row > row){
				return;
			}
			else{
				q = p;
				p = p -> down;
			}
		}
	}
	cout << "删除成功！\n" << endl;
	cout << "删除后的矩阵为：\n" << endl;
	PrintSMatrix(M);
}

/*   *************************************************************************  */

/*                        12. 两个矩阵相加                                      */

void AddMatrix(CrossList &M,CrossList &N, CrossList &out){

	//判断矩阵是否满足相加条件
	if(M.ColSum != N.ColSum || M.rowSum != N.rowSum){
		cout << "两个矩阵不是同类型的,不能相加\n" << endl;
		return;
	}

	//对out矩阵进行初始化
	out.ColSum = M.ColSum;
	out.rowSum = M.rowSum;
	out.NumSum = 0;
	InitSMatrix(out);

	//进行相加
	for(int row = 1; row <= M.rowSum; row++){
		OLink Node1 = M.rhead[row];
		OLink Node2 = N.rhead[row];
		for(int col = 1; col <= M.ColSum; col++){
			//M,N在相同位置都有值
			if(Node1 && Node1 -> col == col && Node2 && Node2 -> col == col){
//               //中间变量保存
//				OLink Node3 = Node1;
//				OLink temp = Node1 -> right;
//				int tmp = Node1 -> elem;
//
//                //插入
//				Node3 -> elem = Node1-> elem + Node2 -> elem;
//				InsertElem(Node3, out);
//				out.NumSum++;
//
//                //移动指针
//                Node1->elem = tmp;
//                Node1 = temp;
//				Node2 = Node2 -> right;

				//赋值
				OLink Node3 = (OLink)malloc(sizeof(OLNode));
				Node3 -> elem = Node1-> elem + Node2 -> elem;
				Node3 -> row = Node1 -> row;
				Node3 -> col = Node1 -> col;
				cout << Node1 -> elem;
				cout << Node2 -> elem;
				cout <<  Node3 -> elem  <<  Node3 -> row  << Node3 -> col << endl;

				//插入 
				InsertElem(Node3, out);
				out.NumSum++;
				
				//移动指针 
                Node1 = Node1 -> right;
				Node2 = Node2 -> right;
			}
			//M位置没有值，N位置有值
			if((Node1==NULL||Node1->col!=col)&& Node2 && Node2->col == col)
            {
//            	//中间变量保存
//				OLink Node3 = Node2;
//				OLink temp = Node2 -> right;
//
//                //插入
//				InsertElem(Node3, out);
//				out.NumSum++;
//
//                //移动指针
//                Node2 = temp;
				
				//赋值 
				OLink Node3 = (OLink)malloc(sizeof(OLNode));
				Node3 -> elem = Node2 -> elem;
				Node3 -> row = Node2 -> row;
				Node3 -> col = Node2 -> col;
				
				//插入 
				InsertElem(Node3,out);
                out.NumSum++;
                
                //移动指针 
                Node2 = Node2->right;
            }
			//M位置有值，N位置没有值
		   if(Node1 && Node1->col == col && (Node2 == NULL||Node2 ->col != col))
            {
//            	//中间变量保存
//            	OLink Node3 = Node1;
//            	OLink temp = Node1 -> right;
//            	
//            	//插入
//				InsertElem(Node3, out);
//				out.NumSum++;
//				
//				//移动指针
//                Node1 = temp;

			
				//赋值 
				OLink Node3 = (OLink)malloc(sizeof(OLNode));
				Node3 -> elem = Node1 -> elem;
				Node3 -> row = Node1 -> row;
				Node3 -> col = Node1 -> col;
				
				//插入 
				InsertElem(Node3,out);
                out.NumSum++;
                
                //移动指针 
                Node1 = Node1->right;
            }
		}
	}
	cout << "相加后的矩阵为：\n" << endl;
	PrintSMatrix(out);
}

/*   *************************************************************************  */

/*                        13. 两个矩阵相减                                      */

void SubtractMatrix(CrossList&M,CrossList &N, CrossList &out){

	//判断矩阵是否满足相减 条件
	if(M.ColSum != N.ColSum || M.rowSum != N.rowSum){
		cout << "两个矩阵不是同类型的,不能相减 \n" << endl;
		return;
	}

	//对out矩阵进行初始化
	out.ColSum = M.ColSum;
	out.rowSum = M.rowSum;
	out.NumSum = 0;
	InitSMatrix(out);

	//进行相减 
	for(int row = 1; row <= M.rowSum; row++){
		OLink Node1 = M.rhead[row];
		OLink Node2 = N.rhead[row];
		for(int col = 1; col <= M.ColSum; col++){
			//M,N在相同位置都有值
			if(Node1 && Node1 -> col == col && Node2 && Node2 -> col == col){
//				//中间变量保存
//				OLink Node3 = Node1;
//				OLink temp = Node1 -> right;
//
//                //插入
//				Node3 -> elem = Node1-> elem - Node2 -> elem;
//				InsertElem(Node3, out);
//				out.NumSum++;
//
//                //移动指针
//                Node1 = temp;
//				Node2 = Node2 -> right;


				//赋值
				OLink Node3 = (OLink)malloc(sizeof(OLNode));
				Node3 -> elem = Node1-> elem - Node2 -> elem;
				Node3 -> row = Node1 -> row;
				Node3 -> col = Node1 -> col;

				//插入 
				InsertElem(Node3, out);
				out.NumSum++;
				
				//移动指针 
                Node1=Node1->right;
				Node2 = Node2 -> right;
			}
			//M位置没有值，N位置有值
			if((Node1 == NULL || Node1 -> col != col) && Node2 && Node2 -> col == col)
            {
//            	//中间变量保存
//				OLink Node3 = Node2;
//				OLink temp = Node2 -> right;
//
//                //插入
//				Node3 -> elem = - Node2-> elem;
//				InsertElem(Node3, out);
//				out.NumSum++;
//
//                //移动指针
//                Node2 = temp;

				//赋值 
				OLink Node3 = (OLink)malloc(sizeof(OLNode));
				Node3 -> elem = - Node2 -> elem;
				Node3 -> row = Node2 -> row;
				Node3 -> col = Node2 -> col;
				
				//插入 
				InsertElem(Node3,out);
                out.NumSum++;
                
                //移动指针 
                Node2 = Node2->right;
            }
			//M位置有值，N位置没有值
		   if(Node1 && Node1 -> col == col && (Node2 == NULL || Node2 -> col != col))
            {
//            	//中间变量保存
//            	OLink Node3 = Node1;
//            	OLink temp = Node1 -> right;
//            	
//            	//插入
//				InsertElem(Node3, out);
//				out.NumSum++;
//				
//				//移动指针
//                Node1 = temp;

				//赋值 
				OLink Node3 = (OLink)malloc(sizeof(OLNode));
				Node3 -> elem = Node1 -> elem;
				Node3 -> row = Node1 -> row;
				Node3 -> col = Node1 -> col;
				
				//插入 
				InsertElem(Node3,out);
                out.NumSum++;
                
                //移动指针 
                Node1 = Node1->right;
            }
		}
	}
	cout << "相减后的矩阵为：\n" << endl;
	PrintSMatrix(out);
}

/*   *************************************************************************  */
 
/*                        14. 两个矩阵相乘                                      */

void MultiplyMatrix(CrossList &M,CrossList &N, CrossList &out){

	//判断矩阵是否满足相乘条件
	if(M.ColSum != N.rowSum){
		cout << "两个矩阵不满足相乘条件 \n" << endl;
		return;
	}
	//对out矩阵进行初始化
	out.rowSum = M.rowSum;
	out.ColSum = N.ColSum;
	out.NumSum = 0;
	InitSMatrix(out);

	//进行相乘

	//行列遍历
	for(int row = 1; row <= out.rowSum; row++){
		for(int col = 1; col <= out.ColSum; col++){
			int elem = 0;
			OLink Node1 = M.rhead[row];
			OLink Node2 = N.chead[col];

			//对M的行，N的列进行遍历
			for(; Node1; Node1 = Node1 -> right){
				for(; Node2 && Node2 -> row <= Node1 -> col; Node2 = Node2 -> down){ 
					if(Node2 -> row == Node1 -> col){//执行相乘
						elem = elem + Node1-> elem * Node2 -> elem;
						break;
					}
				}
			}

			//满足条件插入矩阵
			if(elem){
				out.NumSum++;
                OLink newnode = (OLink)malloc(sizeof(OLNode));
                newnode -> row = row;
                newnode -> col = col;
                newnode -> elem = elem;
                InsertElem(newnode, out);
			}
		}
	}
	cout << "相乘后的矩阵为：\n" << endl;
	PrintSMatrix(out);
}

/*   *************************************************************************  */

/*                        15. 矩阵转置                                   	    */

void TransposeSMatrix(CrossList &M, CrossList &out){

	//out对M进行复制一份
	CopySMatrix(M, out);

	//进行转置
	for(int row = 1; row <= out.rowSum; row++){
		OLink rowNode = out.rhead[row];
		while(rowNode){
			//当结点不为空时，进行指针和下标的交换
			OLink nextRightNode = rowNode -> right;
			
				//下标更换
			int row = rowNode -> row;
			rowNode -> row = rowNode -> col;
			rowNode -> col = row;
				//指针交换
			OLink down = rowNode -> down;
			rowNode -> down = rowNode -> right;
			rowNode -> right = down;
				//对下一个进行判断
			rowNode = nextRightNode;
		}
	}

	//进行转置后的交换
	int rowSum = out.rowSum;
	int ColSum = out.ColSum;
	OLink* rhead = out.rhead;
	out.ColSum = rowSum;
	out.rowSum = ColSum;
	out.rhead = out.chead;
	out.chead = rhead;
    cout << "转置后的矩阵为：\n" << endl;
	PrintSMatrix(out);
	
}

/*   *************************************************************************  */

/*                        16. 矩阵求最值                                    	*/

void findMaxOrMin(CrossList &M){
	int min = INT_MAX;
	int max = INT_MIN;

	//矩阵最大值
    for(int i = 1; i <= M.rowSum; i++){
        OLink p = M.rhead[i];
        while(p != NULL){
            if(max < p -> elem)
             max = p -> elem;
            p = p -> right;
        }
    }
	
	//矩阵最小值
	for(int i = 1; i <= M.rowSum; i++){
        OLink p = M.rhead[i];
        while(p != NULL){
            if(min > p -> elem)
             min = p -> elem;
            p = p -> right;
        }
    }
    cout << "矩阵的最大值为: \n" <<  max << endl;
    cout << "矩阵的最小值为: \n" << min << endl;
}

/*   *************************************************************************  */

/*                        17. 复制矩阵                                          */

void CopySMatrix(CrossList &M, CrossList &out){

	//对out进行初始化
	out.NumSum = M.NumSum;
	out.ColSum = M.ColSum;
	out.rowSum = M.rowSum;
	InitSMatrix(out);
	
	//复制
	for (int row = 1; row <= M.rowSum; row++) 
	{
		OLink rowNode = M.rhead[row];
		while(rowNode)
		{
			OLink newnode = (OLink)malloc(sizeof(OLNode));
			newnode -> row = rowNode -> row;
			newnode -> col = rowNode -> col;
			newnode -> elem = rowNode -> elem;
			InsertElem(newnode, out);
			rowNode = rowNode -> right;
		}
	}
	// printf("复制得到的矩阵为：\n");
	// PrintSMatrix(out);
}

/*   *************************************************************************  */

/*                        18. 从文件中读取                                      */

void ReadFromFile(CrossList &M){
	FILE* fpread;
	char str[100];
	int count=0;
	int num[1000];
	cout << "请输入文件名称:\n" << endl;
	cin >> str;
	fpread = fopen(str, "r");
	if (fpread == NULL)
	{
		cout << "不存在该文件！\n" << endl;
		return ;
	}

	//读取数据
	while(1) { 
		int ch = fgetc(fpread);
		if(ch == EOF)
		 break;
		else
		 fscanf(fpread, "%d", &num[count++]);
	}
	fclose(fpread);

	//初始化矩阵并输出
	M.rowSum = num[0];
	M.ColSum = num[1];
	M.NumSum = num[2];
	InitSMatrix(M);
	cout << num[0] << M.ColSum << M.NumSum << endl;
	for(int i = 3; i < count; i+=3){
		OLink newNode = (OLink)malloc(sizeof(OLNode));
        newNode -> row = num[i];
        newNode -> col = num[i+1];
        newNode -> elem = num[i+2];
        InsertElem(newNode,M);
	}

	//显示矩阵
	cout << "文件中读取的矩阵为：\n" << endl;
	PrintSMatrix(M);
}

/*   *************************************************************************  */

/*                        19. 把矩阵写入文件                                    */

void WriteToFile(CrossList &M){
    char str[1024];
    cout << "请输入需要保存到的文件名:\n" << endl;
	cin >> str;
    FILE* fid = fopen(str, "wt");
	if (fid == NULL)
	{
		cout << "文件不存在！\n" << endl;
		return;
	}

	//写入文件
    fprintf(fid," ");
    fprintf(fid,"%d ",M.rowSum);
    fprintf(fid,"%d ",M.ColSum);
    fprintf(fid,"%d\n",M.NumSum);

    for(int i = 1; i <= M.rowSum; i++){
        OLink Node = M.rhead[i];
        while(Node != NULL){
            fprintf(fid,"%d ",Node -> row);
            fprintf(fid,"%d ",Node -> col);
            fprintf(fid,"%d\n",Node -> elem);
            Node =  Node -> right;
        }
    }
    fclose(fid);
    cout << "文件写入成功！\n" << endl;
}

/*   *************************************************************************  */

/*                        20. 哈希查找函数(用于手动写入矩阵)                    */

CrossList HashFind(char name[10]){
    struct HashCross *tmp = NULL;
    HASH_FIND_STR(cross,name,tmp);
    if(tmp == NULL){
        cout << "该矩阵不存在，系统已经自动为您生成该名称的矩阵\n" << endl;
        CrossList M;
        tmp = (struct HashCross *)malloc(sizeof(struct HashCross));
        strcpy(tmp -> name, name);
        CreateMatrix(M);
        tmp -> crosslist = M;
        HASH_ADD_STR(cross,name,tmp);
        if(cross == NULL) cout << "hash还是空" << endl; 
        return M;
    }
    else{
        cout << "该矩阵存在！\n" << endl;
        return tmp -> crosslist;
    }
}

/*   *************************************************************************  */

/*                        21. 哈希查找函数(用于读文件写入矩阵)                  */

CrossList HashFind2(char name[10]){
    struct HashCross *tmp = NULL;
    HASH_FIND_STR(cross,name,tmp);
    if(tmp == NULL){
    	cout << "该矩阵不存在，系统已经自动为您生成该名称的矩阵\n" << endl;
        tmp = (struct HashCross *)malloc(sizeof(struct HashCross));
        strcpy(tmp -> name, name);
        CrossList M;
        ReadFromFile(M);
        tmp -> crosslist = M;
        HASH_ADD_STR(cross,name,tmp);
        return M;
    }
    else{
    	cout << "该矩阵存在！\n" << endl;
        return tmp -> crosslist;
    }
}

/*   *************************************************************************  */

/*                        21. 获取矩阵名（没有的话，自动创建矩阵）              */

CrossList getCrossList(){
    CrossList M;
    cout << "请输入需要操作的矩阵名称:（长度小于10）\n" << endl;
    char name[10];
    cin >> name;
    M = HashFind(name);
    return M;
}

/*   *************************************************************************  */

/*                       22.主函数调用                                          */


int main(){
	menu();
    return 0;
}

/*   ************************************************************************** */

Phil_jida
关注
  • 10
    点赞
  • 踩
  • 71
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构 - 十字链表之稀疏矩阵的存储
爱吃柚子的好奶罐
02-19 9647
当数组中非零元素非常少时，我们可以称之为稀疏矩阵。为了减少空间的浪费，在存储稀疏矩阵的时候，我们对它进行压缩存储，即指存储非零信息。 一、数组的顺序存储 在存储稀疏矩阵的时候，除了存储非零元素的值，还需要存储其行列号i和j，故每个非零元素要用一个三元组（i, j, v）来描述。因为要与矩阵的对应关系，我们还需要在三元组表中增设非零元素的个数和矩阵行列大小。 那么，稀疏矩阵的数组表达如下所示。 st...
【数据结构】稀疏矩阵的链式存储（十字链表）
Ctrl AC的博客
03-13 1万+
“ Ctrl AC！一起 AC！” 目录 稀疏矩阵的十字链表表示： 十字链表中结点的结构： 创建稀疏矩阵的十字链表表示： 稀疏矩阵十字链表的查找： 稀疏矩阵的十字链表表示： 每一行的非零元素构成一个带表头的环形链表 每一列的非零元素构成一个带表头的环形链表 第i行和第i列的表头是同一个 所有表头结点构成一个新的带表头的环形链表 因此： 十字链表的表示中有非零元素结点和表头结点两类结点 其中表头结点的row,col均为零，表头结点构成的环形链表的表头的row和col分.
十字链表法，十字链表压缩存储稀疏矩阵详解
ZJQ的博客
08-16 3894
例如，A 和 B 分别为两个矩阵，在实现 "将矩阵 B 加到矩阵 A 上" 的操作时，矩阵 A 中的元素会发生很大的变化，之前的非 0 元素可能变为 0，而 0 元素也可能变为非 0 元素。对于此操作的实现，之前。可以看到，使用十字链表压缩存储稀疏矩阵时，矩阵中的各行各列都各用一各链表存储，与此同时，所有行链表的表头存储到一个数组（rhead），所有列链表的表头存储到另一个数组（chead）中。图 2a) 表示的是图 1 中转置之前矩阵的三元组表，2b) 表示的是图 1 中矩阵转置后对应的三元组表。
十字链表实现矩阵存储
qq_53363981的博客
07-04 2715
一、介绍 用十字链表存储稀疏矩阵，可以起到节省空间的作用。 十字链表作为多重链表的一种，其结点分为两种： 类型1：数据域为另一个单链表的头指针。 类型2：数据域为待存储的数据。 其中，“十字”体现在：每一个存储数据的节点都属于两个单链表，从而构成十字形。 用十字链表表示的矩阵，有着以下特征： 1、整体的头指针指向最初的头结点，该头结点一般用于存储矩阵的行数、列数以及其中包含非0元素的数量。 2、由最初的头结点分别横向、纵向展开两个单链表，这两个链表中的每个结点都为类型1。 3、这两个.
【数据结构】数组和字符串（八）：稀疏矩阵的链接存储：十字链表的创建、插入元素、遍历打印（按行、按列、打印矩阵）、销毁
天地玄黄 魑魅魍魉 风花雪月 商角徵羽 暂时停更 十月重见
10-28 1013
本文介绍了稀疏矩阵的链接存储：包括十字链表的创建、插入元素、遍历打印（按行、按列、打印矩阵）、销毁等基本操作
【详解】稀疏矩阵的十字链表✿◡‿◡
2301_80035594的博客
01-12 2375
稀疏矩阵的十字链表表示，对其基本运算全部进行解释并给出代码供大家参考，超详细！！！
十字链表实现稀疏矩阵的各种功能
11-19
十字链表实现稀疏矩阵的加法、减法、乘法、转置、求最值、插入、查看、删除等基本功能，菜单栏采用hash表存储稀疏矩阵，给每个矩阵存储一个名字，hash函数进行寻找。
十字链表实现稀疏矩阵 （自己设计，可用）
10-26
十字链表是实现稀疏矩阵的一种常见方法，它通过链接非零元素来减少存储需求。本项目采用十字链表，并结合uthash库，实现了稀疏矩阵的基本操作。 首先，我们要理解稀疏矩阵的十字链表结构。每个非零元素在链表中表示...
十字链表实现稀疏矩阵的加法
12-10
十字链表实现稀疏矩阵的加法 稀疏矩阵是一种特殊的矩阵，其中大多数元素为零，而非零元素稀疏分布在矩阵之中。为了高效地存储和操作稀疏矩阵，十字链表是一种常用的存储结构。十字链表是一种链式存储结构，每个非零...
十字链表实现稀疏矩阵的乘法
09-03
用C++编写的稀疏矩阵乘法运算，稀疏矩阵采用十字链表存储及计算
十字链表实现稀疏矩阵加法和乘法
12-17
十字链表实现稀疏矩阵加法和乘法
【数据结构】稀疏矩阵的压缩存储（三元组表、十字链表）（C语言）
热门推荐
weixin_51450101的博客
01-27 1万+
目录1. 三元组表1.1 三元组表的存储结构1.2 基于三元组表的矩阵转置1.3 完整实现代码1.4 运行结果2. 十字链表2.1 十字链表的存储结构 稀疏矩阵是指矩阵中大多数元素为零的矩阵。从直观上讲，当非零元素个数低于总元素的30%时，这样的矩阵为稀疏矩阵。 1. 三元组表 1.1 三元组表的存储结构 稀疏矩阵的三元组表表示法是指只存储非零元素，同时存储该非零元素在矩阵中所处的行号和列号的位置信息。 为方便处理，将稀疏矩阵中非零元素对应的三元组按“行序为主序”的一维结构体数组进行存放，将矩阵的每一行（行
稀疏矩阵的链式存储结构：十字链表
最新发布
2302_80372340的博客
04-04 652
int row;//1~n//非零元素所在行，列后继链域//行，列链表的头指针向量int m;//行数int n;//列数int len;//非零元素个数}CrossList;
十字链表存储稀疏矩阵
慎铭的博客
11-23 3273
  对于矩阵的存储，如果矩阵的元素呈有明显规律的排列的话，我们一般用一个一维数组对矩阵进行压缩存储；若矩阵中的元素多数为0，只有少数的元素为非0元素时，我们成该矩阵为稀疏矩阵。 我们有矩阵Aij，其中有非0元素m个，若mij≤0.05，则我们称矩阵Aij为稀疏矩阵 我们有矩阵A_{ij}，其中有非0元素m个，若\frac{m}{ij} \le 0.05，则我们称矩阵A_{ij}为稀疏矩阵 我们有矩阵Aij​，其中有非0元素m个，若ijm​≤0.05，则我们称矩阵Aij​为稀疏矩阵   对于稀疏矩阵，因为非零
十字链表法存储稀疏矩阵
qq_40729286的博客
11-11 870
#include &lt;stdio.h&gt; #include &lt;malloc.h&gt; typedef int ElemType; typedef struct NODE{     int i;//非零元行号     int j;//非零元列号     ElemType e;//非零元     struct NODE* rptr;//行指针     struct NODE* cpt...
广义表的数据结构以及十字链表存储稀疏矩阵
qq_52983712的博客
02-12 464
数据结构
数据结构实验：基于十字链表的稀疏矩阵转置
qq_53454290的博客
11-20 1915
基于十字链表的稀疏矩阵转置
【swjtu】数据结构实验5_基于十字链表的稀疏矩阵转置
qq_52046937的博客
11-12 1037
实验内容及要求： 编写程序，从字符文件读入三个正整数m, n, t以及t个三元组(i, j, e)建立稀疏矩阵的十字链表存储结构。其中，m、n分别表示矩阵行数和列数；i, j为非零元素行号和列号。编写算法，实现矩阵转置，输出转置后的三元组到另一字符文件中，检查你的转置结果是否正确。要求转置时不得新建元素结点(但允许新建行头/列头结点数组以及删除行头/列头结点数组，转置前后，总头结点不允许改变)。 实验目的：掌握稀疏矩阵的十字链表存储结构。 数据结构设计简要描述： 采用三元组...
38、稀疏矩阵的十字链表表示和创建
hopegrace的博客
02-24 3184
用三元数组的结构来表示稀疏矩阵，在某些情况下可以节省存储空间并加快运算速度。但在运算过程中，若稀疏矩阵的非零元素位置发生变化，必将会引起数组中元素的频繁移动。这时，采用链式存储结构(十字链表)表示三元组的线性表更为恰当。 十字链表(orthogonallist)是稀疏矩阵的另一种存储结构。它是用多重链表来存储稀疏矩阵。十字链表适用于操作过程中非零元素的个数及元素位置变动频繁的稀疏矩阵。 一、...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值