数据结构---第五章：数组

于 2022-04-06 22:48:42 发布
阅读量320 收藏
点赞数
文章标签： c++ 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/BH04250909/article/details/123951829
版权

目录

1.三元组表示稀疏矩阵（下面是ARRAY.h头文件）

2.下面是main函数的测试

3.十字链表存储稀疏矩阵，下面是Cross-Chain.h头文件

4.下面是测试

5.在三元组的基础上添加一个快速排序，老师说这个算我们接触的第一个真正意义上的算法： 

1.三元组表示稀疏矩阵（下面是ARRAY.h头文件）

#pragma once

#include<iostream>
#include<malloc.h>
#include<cstdlib>
#include<malloc.h>
#include<ctime>

#define TRUE			  1
#define FALSE			  0
#define OK				  1
#define ERROR			  0
#define INFEASIBLE		 -1
#define M 4
#define N 4
const int   MAXSIZE = 100;		//矩阵最多的元素个数
using namespace std;
typedef int Status;
typedef int ElemType;

typedef struct {
	int i, j;		//i为非零元的行下标，j为非零元的列下标
	ElemType e;		//该非零元的值
}Triple;	//三元组
typedef struct {
	Triple data[MAXSIZE + 1];
	int mu, nu, tu;		//mu为行数，nu为列数，tu为非零元的个数
}TSMatrix;				//构造出来一个三元组

void CreatMatrix(TSMatrix& T, ElemType Array[M][N])
{	//创建->填充一个三元组
	T.mu = M; T.nu = N; T.tu = 0;
	//下面开始扫描Array
	for (int i = 0; i < M; i++)
	{
		for (int j = 0; j < N; j++)
		{
			if (Array[i][j] != 0)
			{
				T.data[T.tu].i = i;
				T.data[T.tu].j = j;
				T.data[T.tu].e = Array[i][j];
				T.tu++;
			}
		}
	}
}

void DispMatrix(TSMatrix t)
{
	if (t.tu <= 0)
	{
		return;
	}
	printf("\t%d\t%d\t%d\n", t.mu, t.nu, t.tu);
	printf("\t------------------\n");
	for (int i = 0; i < t.tu; i++)
	{
		printf("\t%d\t%d\t%d\n", t.data[i].i,t.data[i].j,t.data[i].e);
	}
}

void TranMatrix(TSMatrix t, TSMatrix& tb)
{
	int k1 = 0;
	tb.mu = t.nu; tb.nu = t.mu; tb.tu = t.tu;
	if (tb.tu != 0)
	{
		for (int i = 0; i < t.nu; i++)
		{
			for (int j = 0; j < t.tu; j++)
			{
				if (t.data[j].j == i)
				{
					tb.data[k1].i = t.data[j].j;
					tb.data[k1].j = t.data[j].i;
					tb.data[k1].e = t.data[j].e;
					k1++;
				}
			}
		}
	}
}

bool PlusMatrix(TSMatrix a, TSMatrix b, TSMatrix& c)	//c=a+b
{
	int i=0 , j = 0, k=0;
	ElemType v;
	if (a.mu != b.mu || a.nu != b.nu)
	{
		return false;									//行数和列数不等的矩阵不能相加
	}
	c.mu = a.mu; c.nu = a.nu;
	while (i < a.tu && j < b.tu)
	{
		if (a.data[i].i == b.data[j].i)				//如果行号相等时
		{
			if (a.data[i].j < b.data[j].j)			//a的列号小于b的列号
			{		//把a加到c中去
				c.data[k].i = a.data[i].i;
				c.data[k].j = a.data[i].j;
				c.data[k].e = a.data[i].e;
				k++; i++;
			}
			else if (a.data[i].j > b.data[j].j)			//a的列号大于b的列号
			{		//把b加到c中去
				c.data[k].i = b.data[i].i;
				c.data[k].j = b.data[i].j;
				c.data[k].e = b.data[i].e;
				k++; j++;
			}
			else                             			//a的列号等于b的列号
			{		//把a+b不为零的结果加到c中去
				v = a.data[i].e + b.data[j].e;
				if (v != 0)
				{
					c.data[k].i = a.data[i].i;
					c.data[k].j = a.data[i].j;
					c.data[k].e = v;
					k++;
				}
				i++; j++;
			}
		}
		else if (a.data[i].i < b.data[j].i)				//a的行号小于b的行号
		{		//把a加到c中去
			c.data[k].i = a.data[i].i;
			c.data[k].j = a.data[i].j;
			c.data[k].e = a.data[i].e;
			k++; i++;
		}
		else                                       		//a的行号大于b的行号
		{		//把b加到c中去
			c.data[k].i = b.data[i].i;
			c.data[k].j = b.data[i].j;
			c.data[k].e = b.data[i].e;
			k++; j++;
		}
		c.tu = k;
	}
	return true;
}

int GetValue(TSMatrix t, int i, int j)
{//返回三元组t表示的A[i][j]
	int k = 0;
	while (k < t.tu && (t.data[k].i != i || t.data[k].j != j))
	{
		k++;
	}
	if (k < t.tu)
	{
		return (t.data[k].e);
	}
	else
	{
		return 0;
	}
}

bool MultiplyMatrix(TSMatrix a, TSMatrix b, TSMatrix &c)	//c=a X b
{
	int p = 0;
	ElemType s;
	if (a.nu != b.mu)		//a的列数不等于b的行数，二者不能相乘
	{
		return false;
	}
	for (int i = 0; i < a.mu; i++)
	{
		for (int j = 0; j < b.nu; j++)
		{
			s = 0;
			for (int k = 0; k < a.nu; k++)
			{
				s =s+ GetValue(a, i, k) * GetValue(b, k, j);
			}
			if (s != 0)
			{
				c.data[p].i = i;
				c.data[p].j = j;
				c.data[p].e = s;
				p++;
			}
		}
	}
	c.mu = a.mu; c.nu = b.nu; c.tu = p;
	return true;
}

2.下面是main函数的测试

#include<iostream>
#include<malloc.h>
#include<cstdlib>
#include<malloc.h>
#include<ctime>
#include<cstring>
#include "ARRAY.h"
using namespace std;
#define M 4
#define N 4
int main()
{
	TSMatrix a,b,c;
	ElemType A[M][N] = { {1,0,3,0},{0,1,0,0,} ,{0,0,1,0},{0,0,1,1} };
	ElemType B[M][N] = { {3,0,0,0},{0,4,0,0,} ,{0,0,1,0},{0,0,0,2} };
	/*cout <<"-----"<<M << "X" << N << "的矩阵A" << "-----" << endl;
	for (int i = 0; i < M; i++)
	{
		for (int j = 0; j < N; j++)
		{
			cout << "第" << i + 1 << "行第" << j + 1
				<< "个元素为： ";
			cin >> A[i][j];
		}
	}
	cout << "-----" << M << "X" << N << "的矩阵B" << "-----" << endl;
	for (int i = 0; i < M; i++)
	{
		for (int j = 0; j < N; j++)
		{
			cout << "第" << i + 1 << "行第" << j + 1
				<< "个元素为： ";
			cin >> B[i][j];
		}
	}*/
	CreatMatrix(a, A);
	CreatMatrix(b, B);
	cout << "a的三元组：" << endl; DispMatrix(a);
	cout << "b的三元组：" << endl; DispMatrix(b);
	cout << "a的转置为c：" << endl;
	TranMatrix(a, c);
	cout << endl;
	cout << "c的三元组：" << endl; DispMatrix(c);
	cout << "c=a+b\n";
	PlusMatrix(a, b, c);
	cout << "c的三元组：" << endl; DispMatrix(c);
	cout << "c=a X b\n";
	MultiplyMatrix(a, b, c);
	cout << "c的三元组：" << endl; DispMatrix(c);
	cout << "\n20213002624李季鸿，终于搞出来了！！！" << endl;
	system("pause");
	return 0;
}

3.十字链表存储稀疏矩阵，下面是Cross-Chain.h头文件

#pragma once
#include<iostream>
#include<cstdlib>
#include<malloc.h>
#include<ctime>

#define TRUE			  1
#define FALSE			  0
#define OK				  1
#define ERROR			  0
#define INFEASIBLE		 -1
#define M 4
#define N 4
const int   MTAXSIZE = 100;		//矩阵最多的元素个数
using namespace std;
typedef int Status;
typedef int ElemType; 

typedef struct OLNode {
    int  i, j;    // 该非零元的行和列下标
    ElemType  e;
    struct OLNode* rnext, * cnext;
    // 该非零元所在行表和列表的后继链域
} OLNode, *OLink;

typedef struct {
    OLink* rhead, * chead;
    // 行和列链表头指针向量基址
// 在建立存储结构时分配.
    int    mu, nu, tu;
    // 稀疏矩阵的行数、列数和非零元个数
} CrossList;


int CreateSMTatrix(CrossList* MT)
{
   /* if (MT)
    {
        free(MT);
    }*/
    int m=0, n=0, t = 0;
    cout << "请分别输入稀疏矩阵的行数、列数：" << endl;
    cin >> m;
    cin >> n;
    MT->mu = m; MT->nu = n;
    if (!(MT->rhead = (OLink*)malloc((m + 1) * sizeof(OLink)))) exit(OVERFLOW);
    if (!(MT->chead = (OLink*)malloc((n + 1) * sizeof(OLink)))) exit(OVERFLOW);
    for (int a = 1; a <= m; a++)
    {
        MT->rhead[a] = NULL;
    }
    for (int b = 1; b <= n; b++)  
    {
        MT->chead[b] = NULL;
    }               //清空行和列
    int e;
    for (int i = 1; i <= m; i++)
    {
        for (int j = 1; j <= n; j++)
        {
            cout << "第" << i << "行第" << j
                << "个元素为： ";
            cin >> e;
            if (e != 0)
            {
                t++;
                OLink p,  q;
                if (!(p = (OLNode*)malloc(sizeof(OLNode)))) exit(OVERFLOW);
                p->i = i;
                p->j = j;
                p->e = e; 
                t++;
                p->rnext = NULL;
                p->cnext = NULL; 
                if (MT->rhead[i] == NULL || MT->rhead[i]->j > j)
                {
                    p->rnext = MT->rhead[i];   MT->rhead[i] = p;
                }
                else
                {
                    for (q = MT->rhead[i]; (q->rnext) && q->rnext->j < j; q = q->rnext);
                    p->rnext = q->rnext;    q->rnext = p;
                }
                if (MT->chead[j] == NULL || MT->chead[j]->i > i)
                {
                    p->cnext = MT->chead[j];   MT->chead[j] = p;
                }
                else
                {
                    for (q = MT->chead[j]; (q->cnext) && q->cnext->i < i; q = q->cnext);
                    p->cnext = q->cnext;   q->cnext = p;
                }
            }
        }
    }
    MT->tu = t;
    return OK;
}

void CrossSMTatrix(CrossList MT, ElemType x)
{
    // 在十字链表中查找所有值为 x 的元素并输出(i,j)
    int i = 1;
    OLink p = MT.rhead[i];              // 从第 1 行开始扫描
    while (i <= MT.mu)
    {
        if (!p)   //如果p为空
        {
            i++;
            p = MT.rhead[i]; // p指向下一行 的第一个非零元结点
        }
        else
        {
            if (p->e == x)
            {
                cout << '(' << p->i << ',' << p->j << ')' << endl;// 输出
            }
            p = p->rnext; // 继续查找本行的下一个结点
        }
    }//while
}// CrossSearch


void printSMTatrix(CrossList MT)
{
    OLink pTemp;
    for (int p = 1; p <= MT.mu; p++)
    {
        pTemp = MT.rhead[p];
        for (int q = 1; q <= MT.nu; q++)
        {
            if (pTemp != NULL && pTemp->j == q)
            {
                printf("%5d", pTemp->e);
                pTemp = pTemp->rnext;
            }
            else
            {
                printf("%5d", 0);
            } 
        }
        cout<<"\n";
    }
    return;
}

4.下面是测试

#include<iostream>
#include<malloc.h>
#include<cstdlib>
#include<malloc.h>
#include<ctime>
#include<cstring>
//#include "ARRAY.h"
//#include"Chain-ARRAY.h"
#include"Cross-Chain.h"
using namespace std;
#define M 4
#define N 4
int main()
{
	int x;
	CrossList MT;
	CreateSMTatrix(&MT);
	cout << "在十字链表中查找所有值为 x 的元素并输出(i,j)，请输入x的值：";
	cin >> x;
	CrossSMTatrix(MT, x);
	cout << "打印出全部: "<<endl;
	printSMTatrix(MT);
	cout << "\n20213002624李季鸿，终于搞出来了！！！" << endl;
	system("pause");
	return 0;
}

5.在三元组的基础上添加一个快速排序，老师说这个算我们接触的第一个真正意义上的算法： 

Status FastTranMatrix(TSMatrix TS, TSMatrix& TM)//高级版本的转置
{
	int col;
	int num[100], cpot[50];
	TM.mu = TS.nu;
	TM.nu = TS.mu;
	TM.tu = TS.tu;
	if (TM.tu)
	{
		for (col = 0; col < TS.nu; col++)
		{//num数组置0
			num[col] = 0;
		}
		for (int t = 0; t < TS.tu; t++)
		{//求M中每一列含非零元素个数
			
			++num[TS.data[t].j];
		}
		cpot[0] = 1;		//初始位置
		//求第col列中第一个非零元在b.data的序号
		for ( col = 1; col < TS.nu; col++)
		{
			cpot[col] = cpot[col - 1] + num[col - 1];//前一列的个数加上第一个的位置
		}

		//求出两辅助变量的值
		for (int p = 0; p < TS.tu; ++p)
		{
			col = TS.data[p].j;
			int q = cpot[col]-1;
			cout << q<<" ";
			TM.data[q].i = TS.data[p].j;
			TM.data[q].j = TS.data[p].i;
			TM.data[q].e = TS.data[p].e;
			++cpot[col];
		}
	}
	return OK;
}

BH04250909
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Array.h数组模板
IT_JS_tao的博客
12-02 1449
模板快速了解
第七章-数组-数据结构与数组的概念-影响程序设计的因素优秀文档.ppt
12-01
"数据结构与数组的概念" 本章节主要讲解了数据结构与数组的概念，强调了数据结构在程序设计中的重要性。数据结构是指选择合适的数据类型来存放要处理的数据，而数组是指一组具有同样类型的数据的集合。选择合适的...
Olink 十字链表的实现
11-01 175
1 /*////////////////////////////////// 2 BY WEI 3 2014-10-27 4 //////////////////////////////////*/ 5 #include <iostream> 6 #include <fstream&g...
C++/Array类的实例
weixin_52347118的博客
11-30 816
//头文件/Array.h /*Array.h*/ #pragma once #ifndef ARRAY_H #define ARRAY_H #include <iostream> /**/ class Array { /*友元函数，重载流插入、流提取运算符*/ /*1、用户自定义的类型的数据，要使用流插入"<<"和流提取">>"必须进行重载 2、流插入，流提取只能重载为全局函数，不能重载为成员函数*/ /*1、重载为友元函数，参数的个数等于操作数个数；重载为
学习C++时候写的一个简单Array类
潘伟的专栏
08-04 2045
array.h类接口// Class automatically generated by Dev-C++ New Class wizard/*?* 数组的抽象数据类型，可以实现：?* 1、下标准范围检查?* 2、下标运算?* 3、数组的赋值?* 4、数组比较?* 5、数组的输入/输出?* 6、数组知道自身的大小?*/?#ifndef ARRAY_H#define ARRAY_H#includ
c/c++ 头文件(.h)、源文件(.cpp)书写及接口与实现分离实例
热门推荐
duoluka的博客
03-23 1万+
c++实验代码及学习笔记（二） 全新的代码和文字风格！有趣的算法题和实用基础知识！敬请关注~
第七章-数组数据结构与数组的概念-影响程序设计的因素优秀文档.ppt
12-01
"数组数据结构与数组的概念" 本文档主要介绍了数组数据结构与数组的概念，并对其进行了详细的解释。数组数据结构是指一种存储和组织数据的方式，通过选择合适的数据类型来存放要处理的数据，从而影响程序设计的因素...
c语言学习-第七章-数组完整.pptx
11-14
数组是一种数据结构，由多个相同类型的元素组成，每个元素可以通过下标来访问。数组可以是一维的，也可以是二维或多维的。 2. 一维数组的定义 一维数组的定义格式为：<类型> <数组名>[<常量表达式>]，例如：int a...
数据结构作业：第4-5章作业答案.docx
12-13
数组是一种复杂的数据结构，它是由多个同类型的元素组成的集合。数组的每个元素可以是一个基本类型的数据，也可以是一个复杂的数据结构。数组的存储方式有两种：行优先顺序存储和列优先顺序存储。 在行优先顺序存储...
数据结构作业：第4-5章作业题目.docx
最新发布
12-19
数据结构作业：第4-5章作业题目.docx 数据结构是计算机科学中的一门重要学科，研究的是数据的存储、组织和使用，旨在提高计算机程序的效率和性能。下面是根据提供的文件信息，总结出的相关知识点： 一、数组和串 ...
Array类模板实现
pleasetojava
11-18 370
Array类模板实现 ---------------------------------------------Array.h------------------------------------------------------ #include&lt;string&gt; using namespace std; template&lt;class DataType&gt; cl...
动态数组Array
weixin_60413769的博客
03-14 311
Array.h #ifndef ARRAY_H #define ARRAY_H #include<cassert> template<class T> class Array{ private: T * list;//T类型的指针，用于存放动态分配的数组首地址 int size; public: Array(int sz=50);//构造函数 Array(const Array<T>&a);//复制构造函数
Lighttpd基础篇(二):Array.h
sms88的专栏
10-04 817
//作者：京东瀚览家居官方旗舰店      &lt;--点击关注 //文件名:Array.h   #ifndef ARRAY_H #define ARRAY_H #include &lt;stdlib.h&gt; #ifdef HAVE_CONFIG_H #include "config.h" #endif #ifdef HAVE_PCRE_H # include &lt;pcre.h&...
Lighttpd1.4.20源码分析之array.c(h) -----通用数组
weixin_33836874的博客
10-23 154
Lighttpd提供了一个通用数组，这个数组与程序的其他部分练习较少，因此可以单独进行分析。 首先要说一下Lighttpd中的定义的一些数据结构。 在array.h中有下面的定义： Code1typedefenum{2TYPE_UNSET,/*数据的类型未设置，3这...
【数据结构】稀疏矩阵的链式表示
WINGREZ‘S BLOG
09-11 766
参考资料：《数据结构（C语言版）严蔚敏著》 版权说明：未经作者允许，禁止转载。如引用本文内容，需标明作者及出处。如本文侵犯了您的权益，请联系我删除并致歉。 文章说明：如文章中出现错误，请联系我更改。如您对文章的内容有任何疑问，也欢迎来与我讨论。 本文正在施工中...请稍等... 稀疏矩阵的链式表示 十字链表 typedef struct OLNode{ int i, j; ...
【日常】Caffe编译"gpu/mxGPUArray.h" Not Found错误解决
雷雨中的双桅船
12-08 8401
使用微软的caffe版本(https://github.com/Microsoft/caffe)时遇到了"gpu/mxGPUArray.h" Not Found问题，排查了一下，发现是我装的matlab版本（2016）太新了，修改CommonSettings.props配置如下： E:\02_software\01_develop\matlab
#include <array> 使用方法简介
wardseptember的博客
06-10 4055
数组是固定大小的顺序容器：它们保存一个以严格线性顺序排列的特定数量的元素。在内部，一个数组除了它所包含的元素（甚至不是它的大小，它是一个模板参数，在编译时固定）之外，不保存任何数据。 在存储大小方面与使用语言的括号语法（[]）声明的普通数组一样高效。这个类仅仅为它增加了一层成员函数和全局函数，以便数组可以用作标准容器。 与其他标准容器不同，数组具有固定大小，并且不通过分配器管理其元素的分配：它们...
数据结构 第5章 数组和广义表.ppt
06-17
第五章深入剖析了数组和广义表这两种基础的数据结构，它们在算法设计和实现中起着关键作用。无论是数组的顺序存储和优化，还是广义表的非线性特性，都是理解高级数据结构和算法的关键知识点。掌握这些概念对于从事IT...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值