数据结构12————马鞍点问题&三元组稀疏矩阵&十字链表稀疏链表的加减法

最新推荐文章于 2022-04-28 20:49:13 发布
最新推荐文章于 2022-04-28 20:49:13 发布
阅读量2.3k 收藏 39
点赞数 9
分类专栏： 数据结构与算法 数据结构与算法 文章标签： 稀疏矩阵的加法-实现c-a+b 三元组实现 十字链表实现 马鞍点
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38499859/article/details/78500981
版权

数据结构12————马鞍点问题&三元组稀疏矩阵&十字链表稀疏链表的加减法

文章目录

一.内容

  1. 马鞍点问题
  2. 三元组稀疏矩阵的加减法
  3. 十字链表稀疏矩阵的加减法

二.求矩阵的马鞍点

1.问题描述

这里写图片描述

2.思路
  • 求出每一行的最小值，存到minrows数组中
  • 求出每一列的最大值，存到maxcols数组中
  • 寻找是否存在i和j，使minrows[i]==maxcols[j],如果存在a[i][j]就是马鞍点，否则不存在。
3.代码
#include <stdio.h>
#define MAX 50 
int main(void){
	int i,j;
	int a[MAX][MAX];
	int rows,cols;
	int minrows[MAX],maxcols[MAX];//存储这一行最小和这一行最大值 
	int flag=0;
	scanf("%d%d",&rows,&cols);
	for(i=0;i<rows;i++){
		for(j=0;j<cols;j++){
			scanf("%d",&a[i][j]);
		}
	}
	
	for(i=0;i<rows;i++){
		minrows[i]=a[i][0];
		for(j=1;j<cols;j++){
			if(minrows[i]>a[i][j])
				minrows[i]=a[i][j];
		}
	}	
	
	for(j=0;j<cols;j++){
		maxcols[j]=a[0][j];
		for(i=0;i<rows;i++){
			if(maxcols[j]<a[i][j])
				maxcols[j]=a[i][j];
		}
		
	}
	
	for(i=0;i<rows;i++){
		for(j=0;j<cols;j++){
			if(minrows[i]==maxcols[j])
			{
				printf("(%d,%d,%d)",i+1,j+1,a[i][j]);
				flag=1;
			}	
		}
	}
	if(flag==0){
		printf("NONE");
	}
}

三.三元组稀疏矩阵的加减法

1.问题描述

这里写图片描述

2.代码
#include <stdio.h>
#define MAXSIZE 100
typedef int ElementType;
typedef struct{
	int row,col;           //row行号，col列号 
	ElementType value;
}Triple;
typedef struct{
	Triple data[MAXSIZE+1];
	int rows,clos,nums;       //rows稀疏矩阵的行数，clos稀疏矩阵的列数，nues非0原的个数 
}TSMatrix; 

TSMatrix *Creation(){      //创建 
	TSMatrix *TS;
	Triple Tr;
	char c;
	TS = (TSMatrix *)malloc(sizeof(TSMatrix));
	scanf("%d%d%d",&TS->rows,&TS->clos,&TS->nums); 
	int i;
	getchar();;//这句是为了应付学校的acm
	for(i=0;i<TS->nums;i++){
		scanf("%c%d%c%d%c%d%c",&c,&Tr.row,&c,&Tr.col,&c,&Tr.value,&c);
		TS->data[i]=Tr;
	}
	return TS;
} 

void Output(TSMatrix *TS){ //输出 
	int i;
	printf("%d %d %d\n",TS->rows,TS->clos,TS->nums);
	for(i=0;i<TS->nums;i++){
		printf("(%d,%d,%d)",TS->data[i].row,TS->data[i].col,TS->data[i].value);
	}
	printf("\n");
}
TSMatrix *Add(TSMatrix *TS1,TSMatrix *TS2){ //加法 
	int i=0,j=0;
	TSMatrix *TS3;
	Triple Tr;
	TS3 = (TSMatrix *)malloc(sizeof(TSMatrix));
	TS3->nums=0;
	
	while(i<TS1->nums&&j<TS2->nums){
		if(TS1->data[i].row<TS2->data[j].row){       //TS1行号小于TS2 
			Tr=TS1->data[i];
			i++;
		}else if(TS1->data[i].row>TS2->data[j].row){ //TS1行号大于TS2 
			Tr=TS2->data[j];
			j++; 
		}else if(TS1->data[i].col<TS2->data[j].col){  //TS1行号等于TS2 TS1列号小于TS2 
			Tr=TS1->data[i];
			i++;
		}else if(TS1->data[i].col>TS2->data[j].col){  //TS1行号等于TS2 TS1列号大于TS2 
			Tr=TS2->data[j];
			j++;
		}else {         //TS1行号列号等于TS2 ,即相加 
			Tr=TS1->data[i];
			Tr.value= TS1->data[i].value+TS2->data[j].value;
			i++;
			j++;
		} 
		if(Tr.value	!=0){
				TS3->data[TS3->nums]=Tr;
				TS3->nums++;
		}	
	}
	while(i<TS1->nums){
		TS3->data[TS3->nums]=TS1->data[i];
		i++;TS3->nums++;
	}
	while(j<TS2->nums){
		TS3->data[TS3->nums]=TS2->data[j];
		j++;TS3->nums++;
	}
	TS3->rows=TS2->rows;
	TS3->clos=TS2->clos;
	return TS3;
}
 
TSMatrix *Sub(TSMatrix *TS1,TSMatrix *TS2){  //减法 
	int i=0,j=0,t;
	TSMatrix *TS3;
	Triple Tr;
	TS3 = (TSMatrix *)malloc(sizeof(TSMatrix));
	TS3->nums=0;
	while(i<TS1->nums&&j<TS2->nums){
		if(TS1->data[i].row<TS2->data[j].row){       //TS1行号小于TS2 
			Tr=TS1->data[i];
			i++;
		}else if(TS1->data[i].row>TS2->data[j].row){ //TS1行号大于TS2 
			Tr=TS2->data[j];
			Tr.value=-Tr.value;
			j++;
		}else if(TS1->data[i].col<TS2->data[j].col){  //TS1行号等于TS2 TS1列号小于TS2 
			Tr=TS1->data[i];
			i++;
		}else if(TS1->data[i].col>TS2->data[j].col){  //TS1行号等于TS2 TS1列号大于TS2 
			Tr=TS2->data[j];
			Tr.value=-Tr.value;
			j++;
		}else { 
			Tr=TS1->data[i];									//TS1行号列号等于TS2 
			Tr.value=TS1->data[i].value - TS2->data[j].value;
			i++;j++;
		} 
		
		if(Tr.value!=0){
				TS3->data[TS3->nums]=Tr;
				TS3->nums++;
		}	
	}
	while(i<TS1->nums){
		TS3->data[TS3->nums]=TS1->data[i];
		i++;TS3->nums++;
	}
	while(j<TS2->nums){
		Tr=TS2->data[j];
		Tr.value=-TS2->data[j].value;
		TS3->data[TS3->nums]=Tr;
		j++;TS3->nums++;
	}
	TS3->rows=TS2->rows;
	TS3->clos=TS2->clos;
	return TS3;
}
int main(void){
	TSMatrix *TS1;
	TSMatrix *TS2;
	TSMatrix *TS3;
	TSMatrix *TS4;
	TS1=Creation();
	TS2=Creation(); 
	TS3=Add(TS1,TS2);
	TS4=Sub(TS1,TS2); 
	Output(TS3);
	Output(TS4);
	
}

四.十字链表稀疏矩阵的加减法

1.问题描述

这里写图片描述

2.代码
#include <stdio.h>
#include <stdlib.h>
#define MAX 50
typedef int Elemtype;
typedef struct OLnode{
	int row,col;
	Elemtype value;
	struct OLnode *right,*down;
}OLNode,*OLink;
typedef struct {
	OLink rowhead[MAX],colhead[MAX];
	int rows,cols,nums;
}CrosList;

void Insert(CrosList *CL,OLNode *node){ //插入 
	OLNode *p;
	node->right=NULL;
	node->down=NULL;
	
	//插入到行中 
	if(CL->rowhead[node->row-1]==NULL)
		CL->rowhead[node->row-1]=node;
	else{                           //插入到行链里 
		p=CL->rowhead[node->row-1];
		while(p->right&&node->row > p->right->row){
			p=p->right;
		};
		node->right=p->right;
		p->right=node;
	}
		
	if(CL->colhead[node->col-1]==NULL)
		CL->colhead[node->col-1]=node;
	else{                           //插入到列链中 
		p=CL->colhead[node->col-1];
		while(p->down&&node->col > p->down->col){
			p=p->down;
		};
		node->down=p->down;
		p->down=node;
	}
}

CrosList *Creation(){ //创建 
	CrosList *CL;
	OLNode *node;
	OLNode *p;
	CL = (CrosList *)malloc(sizeof(CrosList));
	scanf("%d%d%d",&CL->rows,&CL->cols,&CL->nums);
	int i;
	for(i=0;i<CL->rows;i++)
		CL->rowhead[i]=NULL;
	for(i=0;i<CL->cols;i++)
		CL->colhead[i]=NULL;
		 
	 getchar();
	for(i=0;i<CL->nums;i++){
		node = (OLNode*)malloc(sizeof(OLNode));
		scanf("(%d,%d,%d)",&node->row,&node->col,&node->value);
		Insert(CL,node); //插入 
	}
	return CL;
} 
void Output(CrosList *CL){  //输出 
	int i;
	OLNode *node;
	if(CL==NULL)
		return; 
	printf("%d %d %d\n",CL->rows,CL->cols,CL->nums);
	for(i=0;i<CL->rows;i++){
		node = CL->rowhead[i];
		while(node){
			printf("(%d,%d,%d)",node->row,node->col,node->value);
			node=node->right;			
		}
		
	} 
	printf("\n");
	
	/*printf("%d %d %d",CL->rows,CL->cols,CL->nums); //列优先输出 
	for(i=0;i<CL->cols;i++){
		node = CL->colhead[i];
		while(node){
			printf("(%d,%d,%d)",node->row,node->col,node->value);
			node=node->down;			
		}
	} 
	printf("\n");*/

} 

int Inquire (CrosList *CL,OLNode *node){  //查询该位置是否有元素
	int i=node->row;
	int j=node->col;
	OLNode *p;
	if(CL->rowhead[i]==NULL||CL->colhead[j]==NULL)
		return 0;
	p=CL->rowhead[i];
	while(p&&p->row!=node->row&&p->col!=node->col){
		p=p->right;	
	} 
	if(p->row==node->row && p->col==node->col)
		return 1;
		
	return 0;
} 
CrosList *ADD(CrosList *CL1,CrosList *CL2){
	OLNode *pi,*pj,*pk;
	int i;
	CrosList *CL3;
	CL3 = (CrosList *)malloc(sizeof(CrosList));
	CL3->rows=CL1->rows;
	CL3->cols=CL2->cols;
	CL3->nums=0; 
	for(i=0;i<CL3->rows;i++)//初始化 
		CL3->rowhead[i]=NULL;
	for(i=0;i<CL3->cols;i++)
		CL3->colhead[i]=NULL;
		
	for(i=0;i<CL1->rows;i++){
		pi = CL1->rowhead[i];
		pj = CL2->rowhead[i];
		while(pi&&pj){
			pk=(OLNode*)malloc(sizeof(OLNode));
			if(pi->row < pj->row){        //CL1行号小于CL2 
				pk->row=pi->row;
				pk->col=pi->col;
				pk->value=pi->value;
				pi=pi->right;
			}else if(pi->row > pj->row){   //CL1行号大于CL2 
				pk->row=pj->row;
				pk->col=pj->col;
				pk->value=pj->value;
				pj=pj->right;
			}else if(pi->col < pj->col ){   //CL1行号等于Cl2 Cl1列号小于Cl2
				pk->row=pi->row;
				pk->col=pi->col;
				pk->value=pi->value;
				pi=pi->right;
			}else if(pi->col > pj->col ){    //CL行号等于CL2 Cl1列号大于Cl2 
				pk->row=pj->row;
				pk->col=pj->col;
				pk->value=pj->value;
				pj=pj->right;
			}else{							//CL1行号列号等于CL2 ,即相加 
				pk->row=pi->row;
				pk->col=pi->col;
				pk->value=pi->value+pj->value;
				pi=pi->right;
				pj=pj->right;
			}
			if(pk->value!=0){
				Insert(CL3,pk);//插入 
				CL3->nums++;	
			}		
						
		}
		while(pi){
			pk=(OLNode*)malloc(sizeof(OLNode));
			pk->row=pi->row;
			pk->col=pi->col;
			pk->value=pi->value;
			pi=pi->right;	
			Insert(CL3,pk);//插入 
			CL3->nums++;
		}
		while(pj){
			pk=(OLNode*)malloc(sizeof(OLNode));
			pk->row=pj->row;
			pk->col=pj->col;
			pk->value=pj->value;
			pj=pj->right;	
			Insert(CL3,pk);//插入 
			CL3->nums++;
		}
	} 
	return CL3;
} 
CrosList *Sub(CrosList *CL1,CrosList *CL2){
	OLNode *pi,*pj,*pk;
	int i;
	CrosList *CL4;
	CL4 = (CrosList *)malloc(sizeof(CrosList));
	CL4->rows=CL1->rows;
	CL4->cols=CL2->cols;
	CL4->nums=0; 
	for(i=0;i<CL4->rows;i++)//初始化 
		CL4->rowhead[i]=NULL;
	for(i=0;i<CL4->cols;i++)
		CL4->colhead[i]=NULL;
		
	for(i=0;i<CL1->rows;i++){
		pi = CL1->rowhead[i];
		pj = CL2->rowhead[i];
		while(pi&&pj){
			pk=(OLNode*)malloc(sizeof(OLNode));
			if(pi->row < pj->row){        //CL1行号小于CL2 
				pk->row=pi->row;
				pk->col=pi->col;
				pk->value=pi->value;
				pi=pi->right;
			}else if(pi->row > pj->row){   //CL1行号大于CL2 
				pk->row=pj->row;
				pk->col=pj->col;
				pk->value=-pj->value;
				pj=pj->right;
			}else if(pi->col < pj->col ){   //CL1行号等于Cl2 Cl1列号小于Cl2
				pk->row=pi->row;
				pk->col=pi->col;
				pk->value=pi->value;
				pi=pi->right;
			}else if(pi->col > pj->col ){    //CL行号等于CL2 Cl1列号大于Cl2 
				pk->row=pj->row;
				pk->col=pj->col;
				pk->value=-pj->value;
				pj=pj->right;
			}else{							//CL1行号列号等于CL2 ,即相加 
				pk->row=pi->row;
				pk->col=pi->col;
				pk->value=pi->value-pj->value;
				pi=pi->right;
				pj=pj->right;
			}
			if(pk->value!=0){
				Insert(CL4,pk);//插入 
				CL4->nums++;	
			}		
						
		}
		while(pi){
			pk=(OLNode*)malloc(sizeof(OLNode));
			pk->row=pi->row;
			pk->col=pi->col;
			pk->value=pi->value;
			pi=pi->right;	
			Insert(CL4,pk);//插入 
			CL4->nums++;
		}
		while(pj){
			pk=(OLNode*)malloc(sizeof(OLNode));
			pk->row=pj->row;
			pk->col=pj->col;
			pk->value=- pj->value;
			pj=pj->right;	
			Insert(CL4,pk);//插入 
			CL4->nums++;
		}
	} 
	return CL4;
} 
int main(void){
	CrosList *CL1=NULL;
	CrosList *CL2=NULL;
	CrosList *CL3=NULL;
	CrosList *CL4=NULL;
	CL1=Creation();
	CL2=Creation();
	CL3=ADD(CL1,CL2);
	CL4=Sub(CL1,CL2);
	Output(CL3);
	Output(CL4);
}

五.源代码

test11中

冰炭不投day
关注
专栏目录
马鞍点问题
10-13
马鞍点问题的代码
三元组表示的矩阵求鞍点（C语言实现）
问道刘
05-08 2267
三元组表示的矩阵求鞍点（C语言实现） 普通大学生，用最笨的方法求鞍点，忽略庞大时间复杂度，纯暴力检索，代码本来是为了存储稀疏矩阵的，里面也有快速转置的算法，在此基础上，写了求鞍点的方法，虽然很笨拙，但是也写出来了，有时间复杂度低的想法欢迎大家留言呀！ 转载请附上原文链接 代码如下： #include "stdio.h" #include "stdlib.h" #include "stri...
基于三元组表储存稀疏矩阵求鞍点(C语言版)
midi
12-23 655
基于三元组表储存稀疏矩阵求鞍点 数据结构课 #include<stdio.h> #include<stdlib.h> #define Maxsize 10 typedef struct{ //定义三元组表 int i,j; int v; }TriTupleNode; typedef struct{ //定义三元组表 TriTupleNode data[Maxsize]; int m; int n; int t; //矩阵行，列及三元组表长度 }
稀疏矩阵的十字链表表示法及其加法减法运算算法
LLXLQY的博客
03-29 2038
#include #include using namespace std; #define ERROR -1 typedef struct OLNode{ int i,j,e; struct OLNode *right,*down; }OLNode,*OLink; typedef struct{ OLink *rhead,*chead; int mu,nu,tu; }Cro
数据结构--数组--马鞍点
复兴之路
07-31 3921
如果矩阵A中存在这样的一个元素A[i][j]满足我条件:A[i][j]是第i行中值最小的元素，且又是第j列中值最大的元素，则称之为该矩阵的一个马点。编写一个程序计算出m*n的矩阵A的所有马鞍点 #include "stdio.h" #define n 3 #define m 3 void Get_Saddle(int A[m][n])/*求矩阵A中的马鞍点*/ { int i,j
C# 数据结构——三元组与十字链表——稀疏矩阵
08-02
本主题主要关注的是如何在C#环境中利用三元组（Triple）和十字链表（Cross-linked List）来实现稀疏矩阵及其相关的加法、减法和乘法操作。 稀疏矩阵是一种针对那些大部分元素为零的矩阵的优化存储方式。通常，我们...
数据结构实验报告4-数组与广义表-基于十字链表的稀疏矩阵转置-实验内容及要求.docx
07-06
2. **构建十字链表**：根据读取的数据构建稀疏矩阵的十字链表存储结构。每个结点包含行、列、数据域三个数值和指向下一个结点的两个指针（行方向和列方向）。 3. **实现矩阵转置**：编写算法实现稀疏矩阵的转置操作...
数据结构综合课设稀疏矩阵的完全链表表示及其运算.docx
03-26
【数据结构综合课设——稀疏矩阵的完全链表表示及其运算】 在计算机科学中，稀疏矩阵（Sparse Matrix）是指非零元素数量远小于总元素数量的矩阵。当处理大量数据时，为了节省存储空间和提高计算效率，通常会采用...
稀疏矩阵十字链表
10-05
稀疏矩阵十字链表
基于十字链表存储的稀疏矩阵的转置
04-28
总结来说，这个C++程序展示了如何利用十字链表有效地处理稀疏矩阵的转置问题，通过文件读写操作实现了数据的输入和输出，同时保持了数据结构的高效性和可读性。这种实现方法对于处理大型稀疏矩阵尤其有价值，因为它...
数据结构中马鞍点有关程序
05-13
可求出矩阵中的马鞍点，及在矩阵中行中最小但列中最大的点。数据结构教程中的上机实验。#include<stdio.h> int main() { int n, m, i, j, k, l, minn, maxx, flag ; int a[256][256]; while(1) { printf("请输入矩阵的行列数：\n"); scanf("%d %d",&n,&m); printf("请输入与行列数相符的矩阵：\n"); for( i =0 ;i < n ;i++) for( j =0 ;j < m; j++) scanf("%d",&a[i][j]);
鞍点问题 数据结构实验
04-29
鞍点问题： 若矩阵A中的某一元素A[i,j]是第i行中的最小值，而又是第j列中的最大值，则称A[i,j]是矩阵A中的一个鞍点。写出一个可以确定鞍点位置的程序。 关于输出：有即输出 没有鞍点则无提示 矩阵输入结束后出现的矩阵式测试用的 可以忽略。
马鞍点问题【数组】
C++的星空
11-20 1552
        如果在一矩阵中元素A[i][j]满足A[i][j]为第i行的最小值，第j行的最大值，则称这个元素为这个矩阵的马鞍点，求m*n矩阵所有的马鞍点。若需求一个矩阵的所有马鞍点，其实只需将矩阵的每行的最小值与每列的最大值分别求出存在相应的数组中，在遍历一遍原矩阵确定元素是否满足条件即可。 #include &lt;cstdio&gt; #include &lt;iostream&gt;...
【数据结构】实验七 求一个矩阵的马鞍点
weixin_61693556的博客
04-28 3696
实验内容： 如果矩阵A中存在这样的一个元素，满足条件： A[i][j]是第i行中值最小的元素，且是第j列中值最大的元素，则称之为该矩阵的一个马鞍点。 设计程序计算一个m*n的矩阵A的所有马鞍点。 实验目的：掌握数组基本操作及算法设计。 #include<iostream> #define MAX 50 using namespace std; void InitArray(int a[MAX][MAX], int m, int n) // 初始化矩阵中的元素 { cout <&lt.
数据结构求一个矩阵的马鞍点
热门推荐
a716121的专栏
04-21 1万+
马鞍点就是本行中最小的但是本列中最大的数 如图： 代码： #include #include #include using namespace std; #define M 4 #define N 4 int minn[M],maxx[N]; void MinMax(int A[M][N])///M行中最小，N列中最大 { int i,j; bool have=fals
求解马鞍点问题
Madrid-7的博客
04-06 2505
题目描述 若矩阵An*m中某个元素A[i][j]是矩阵第i行中值最小的元素，同时又是第j列中值最大的元素，则称元素A[i][j]是矩阵中的一个马鞍点。设以二维数组存储矩阵，编写算法求矩阵A中的所有马鞍点，算法的时间复杂度要尽量的低。 注意当最大值（最小值）并列相等时，会出现多鞍点的情况。 输入 第一行输入矩阵的总行数M和总列数N，以空格间隔。 之后的M行，依次输入矩阵的各行数据，以空格间隔。 输出 若有马鞍点，则以行序为主序，依次输出各个马鞍点。每个马鞍点以（row,col,val）的形式输出，其中row
西电数据结构上机题——寻找马鞍点
兴趣使然的创作者
11-11 1451
这题几乎花了我两个小时 本来想白嫖一下网上马鞍点成果 结果发现 他们全是用二维数组做的 然后经过思考，发现用数据结构做比用二维数组思路简单 注意有个坑，输入定死是从1开始，导致我一开始检查了半天才发现。 //找马鞍点程序代码 #include<stdio.h> #include<malloc.h> //数组的结构类型定义 const int m=3; const int n=3; typedef struct{ int A[m+1][n+1]; int max[m+1],min[
马鞍数求助
weixin_45917130的博客
12-09 1145
若一个矩阵中的某元素在其所在行最小而在其所在列最大，则该元素为矩阵的一个马鞍点。 请写一个程序，找出给定矩阵的马鞍点。 输入说明 输入数据第一行只有两个整数m和n（0<m<100,0<n<100），分别表示矩阵的行数和列数； 接下来的m行、每行n个整数表示矩阵元素（矩阵中的元素互不相同），整数之间以空格间隔。 输出说明 在一行上输出马鞍点的行号、列号（行号和列号从0开始...
马鞍点的求解
01-01 1217
#include #include #include const int MAX=100; int main() {  int array[MAX][MAX];   int h,l;  //行，列数值  int i,j,k;   int ah,al;  //下角标  int min;  bool tf;  cout  cin>>h>>l;  cout  for(i=0;i  {   for(j=0
数据结构：稀疏矩阵的三元组顺序表压缩存储
"本文主要介绍了数据结构中的三元组顺序表，这是稀疏矩阵的一种压缩存储方式，适用于存储非零元素较少的矩阵。此外，还回顾了数组和广义表的相关概念，包括一维数组、二维数组以及多维数组的定义和特性。" 在数据...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值