数据结构——矩阵
数据结构实验五矩阵的压缩存储与运算学习资料
数据结构实验五矩阵的压缩存储与运算第五章矩阵的压缩存储与运算【实验目的】1. 熟练掌握稀疏矩阵的两种存储结构(三元组表和十字链表)的实现；2. 掌握稀疏矩阵的加法、转置、乘法等基本运算；3. 加深对线性表的顺序存储和链式结构的理解。
第一节知识准备矩阵是由两个关系（行关系和列关系）组成的二维数组，因此对每一个关系上都可以用线性表进行处理；考虑到两个关系的先后，在存储上就有按行优先和按列优先两种存储方式，所谓按行优先，是指将矩阵的每一行看成一个元素进行存储；所谓按列优先，是指将矩阵的每一列看成一个元素进行存储；这是矩阵在计算机中用一个连续存储区域存放的一般情形，对特殊矩阵还有特殊的存储方式。
一、特殊矩阵的压缩存储1. 对称矩阵和上、下三角阵若n阶矩阵A中的元素满足= （0≤i，j≤n-1 ）则称为n阶对称矩阵。
对n阶对称矩阵，我们只需要存储下三角元素就可以了。
事实上对上三角矩阵（下三角部分为零）和下三角矩阵（上三角部分为零），都可以用一维数组ma[0.. ]来存储A的下三角元素（对上三角矩阵做转置存储），称ma为矩阵A的压缩存储结构，现在我们来分析以下，A和ma之间的元素对应放置关系。
问题已经转化为：已知二维矩阵A[i，j]，如图5-1，我们将A用一个一维数组ma[k]来存储，它们之间存在着如图5-2所示的一一对应关系。
任意一组下标(i,j)都可在ma中的位置k中找到元素m[k]= ；这里：k=i(i+1)/2+j (i≥j)图5-1 下三角矩阵a00 a10 a11 a20 … an-1,0 … an-1,n-1k= 0 1 2 3 …n(n-1)/2 …n(n+1)/2-1图5-2下三角矩阵的压缩存储反之，对所有的k=0,1，2,…,n(n+1)/2-1，都能确定ma[k]中的元素在矩阵A中的位置（i,j）。
这里，i=d-1，（d是使sum= > k的最小整数），j= 。
2. 三对角矩阵在三对角矩阵中，所有的非零元素集中在以主对角线为中心的带内状区域中，除了主对角线上和直接在对角线上、下方对角线上的元素之外，所有其它的元素皆为零，见图5-3。
数据结构矩阵加法
数据结构矩阵加法
一、数据结构矩阵加法是什么呢？
嘿呀，宝子们！今天咱们来唠唠数据结构里的矩阵加法。
矩阵就像是一个方格阵，里面装着好多数字呢。
矩阵加法呢，可不是简单地把两个矩阵放在一块儿就完事儿啦。
它是要把对应的方格里面的数字相加哦。
比如说有矩阵A和矩阵B，A的第一行第一列的数字就要和B的第一行第一列的数字相加，得到新矩阵相应位置的数字。
二、怎么去做矩阵加法呢？
这就像是玩数字对对碰的游戏。
首先得保证两个矩阵的行数和列数是一样的。
要是不一样的话，就像两个人玩游戏，规则都不一样，那可没法玩加法这个游戏啦。
假设矩阵A是一个2行3列的矩阵，矩阵B也得是2行3列的。
然后就一个一个方格对着加呗。
就像给每个小方格里面的数字找个小伙伴，然后把它们凑一块儿。
三、矩阵加法在实际中有啥用呢？
这用处可大了去了。
在计算机图形学里，矩阵加法就像魔法一样。
比如说我们要把一个图形移动到另一个位置，就可以用矩阵来表示这个图形，然后通过矩阵加法来计算它移动后的新位置。
还有在物理学里，矩阵加法也能用来计算一些物理量的叠加呢。
就好比两个力作用在一个物体上，我们可以用矩阵来表示这两个力，然后用矩阵加法算出它们叠加后的效果。
概括来说呀，矩阵加法虽然看起来就是数字的相加，但是在很多领域都是超级重要的小能手呢。
它就像一把万能钥匙，能打开好
多不同领域的大门。
数据结构 第4章 矩阵乘法
用经典算法。
α11 A α21
α31
α12 α22 α32
α13 α23 α33
α14
α24
B
α34
b11 b21 b31 b41
b12 b22 b32 b42
b13
b23
b33
Q
b43
A*B
c11 c21 c31
c12 c22 c32
c13
c23
c33
4
cij aik bkj ai1b1 j ai2b2 j ai3b3 j ai4b4 j , i 1,2,3, j 1,2,3
ci1 ai1b11 ai2b21 ai3b31 ai4b41 ci2 ai1b12 ai2b22 ai3b32 ai4b42 ci3 ai1b13 ai2b23 ai3b33 ai4b43
注意：对任意k=1,2,3,4，乘 积项aikbkj 必是且只能是cij求 和公式中的一项， 故可改变 计算aikbkj 的次序。
b23
b33 b43
C
A*B
c11 c21
c31
c12 c22 c32
c13
c23
c33
cij aik bkj ai1b1 j ai2b2 j ai3b3 j ai4b4 j , i 1,2,3, j 1,2,3
k 1
经典算法中乘积项aikbkj计算次序
ci1 ai1b11 ai2b21 ai3b31 ai4b41 ci2 ai1b12 ai2b22 ai3b32 ai4b42
b12 b22 b32 b42
b13
b23
C
b33
b43
A*B
c11 c21 c31
数据结构课程设计-图的邻接矩阵
数据结构课程设计报告设计题目：图的邻接矩阵存储结构院系计算机学院年级x 级学生xxxx学号xxxxxxxxxx指导教师xxxxxxxxx起止时间10-6/10-102013年10月10日目录1 需求分析 (3)2 概要设计 (4)2.1 ADT描述 (4)2.2程序模块结构 (5)2.3各功能模块 (6)3详细设计 (7)3.1类的定义 (7)3.2 初始化 (8)3.3 图的构建操作 (8)3.4 输出操作 (9)3.5 get操作 (9)3.6 插入操作 (10)3.7 删除操作 (10)3.8 求顶点的度操作 (11)3.10 判断连通操作 (12)3.11 主函数 (13)4 调试分析 (16)4.1调试问题 (16)4.2 算法时间复杂度 (16)5用户手册 (16)5.1 主界面 (16)5.2 创建图 (17)5.3插入节点 (17)5.4 深度优先遍历 (17)5.5 求各顶点的度 (18)5.6 输出图 (18)5.7 判断是否连通 (19)5.8 求边的权值 (19)5.9 插入边 (19)5.10 删除边 (20)结论 (20)参考文献 (20)摘要随着计算机的普及，涉及计算机相关的科目也越来越普遍，其中数据结构是计算机专业重要的专业基础课程与核心课程之一，为适应我国计算机科学技术的发展和应用，学好数据结构非常必要，然而要掌握数据结构的知识非常难，所以对“数据结构”的课程设计比不可少。
本说明书是对“无向图的邻接矩阵存储结构”课程设计的说明。
首先是对需求分析的简要阐述，说明系统要完成的任务和相应的分析，并给出测试数据。
其次是概要设计，说明所有抽象数据类型的定义、主程序的流程以及各程序模块之间的层次关系，以及ADT描述。
然后是详细设计，描述实现概要设计中定义的基本功操作和所有数据类型，以及函数的功能及代码实现。
再次是对系统的调试分析说明，以及遇到的问题和解决问题的方法。
然后是用户使用说明书的阐述，然后是测试的数据和结果的分析，最后是对本次课程设计的结论。
数据结构矩阵转置
数据结构矩阵转置
数据结构中的矩阵转置指的是矩阵中元素位置的改变。
当矩阵中原来
横纵坐标对应的数据发生变化，而元素位置不变时就是矩阵的转置。
在矩
阵转置的过程中，列变行，行变列，维度保持不变。
矩阵转置的概念：
矩阵的转置是指将一个m*n矩阵A的元素按照Aij=Aji的规律进行重
新排列而成为另一个n*m矩阵B，它就是矩阵A的转置矩阵，表示为BT。
由矩阵转置的定义可以得出，矩阵转置的过程会使矩阵的行列发生变化，而维度保持不变，即原来m*n矩阵转置之后仍为n*m矩阵，这其实就
是将二维l矩阵的行列颠倒，看起来像是把矩阵（腾空间）旋转了90度。
矩阵转置的特性：
1.交换性：(A^T)^T=A
2.矩阵乘法中，AB和BA相等时：(AB)^T=B^TA^T
矩阵转置的实现方式：
1.暴力法：
采用暴力法实现矩阵转置，其步骤如下：
（1）申请n*m的空间，用来存储转置后的矩阵
（2）以行为单位，读取第i行的元素，不断存入转置后的第i列中
（3）依次完成全部元素的赋值
2.零判断法：
此种方式可减小重复赋值的次数，其步骤如下：（1）申请n*m的空间，用来存储转置后的矩阵（2）以行为单位。
数据结构 矩阵的转置
printf("%d\t",M.data[t].e);
t++;
}
else printf("0\t");
}
printf("\n");
}
return OK;
}
Status TransposeSMatrix(TSMatrix M,TSMatrix &T)
{
T.mu=M.nu;T.nu=M.mu;T.tu=M.tu; int col; int p,q;
T.data[q].j= M.data[p]. i;
T.data[q].e= M.data[p]. e;
++cpot[col] ;
}
}
printf("矩阵快速转置成功！\n");
printf("转置后的");
ShowSMatrix(T);
return OK;
}
int main()
{
printf("******************************\n");
#include<stdio.h>
#include <conio.h>
#define MAXSIZE 12500
#define OK 1
#define ERROR 0
#define OVERFLOW -2
typedef int Status;
typedef int ElemType;
typedef struct
{
printf("输入重复！\n");
w--;
break;
数据结构之特殊矩阵
数据结构之特殊矩阵特殊矩阵：即指⾮零元素或零元素的分布有⼀定规律的矩阵，为了节省存储空间，我们可以对这类矩阵进⾏压缩存储；即为多个相同的⾮零元素只分配⼀个存储空间；对零元素不分配空间⼀、稀疏矩阵稀疏矩阵:设矩阵A中有s个⾮零元素，若s远远⼩于矩阵元素的总数，则称A为稀疏矩阵。
如果我们把整个数据存⼊内存，如果每个单元格⼀个字节则需要6*5个字节我们要对稀疏矩阵进⾏压缩存储：即只存储稀疏矩阵中的⾮零元素和矩阵的⼤⼩；采⽤三元组的表⽰⽅式例如：(6,5,30)矩阵⼤⼩、（0,3,34）、（1,1,1）、（1,3,3）、（1,4,59）、（2,0,23）、（2,2,12）、(3,1,45)、(3,3,51)、(3,4,46)、(4,2,34)、(5,0,78)、(5,2,56)、(5,4,2)稀疏矩阵占⽤空间⼤⼩：7*3个字节⼆、三⾓矩阵：上三⾓矩阵、下三⾓矩阵三⾓矩阵中的重复元素c(常量)可共享⼀个存储空间，其余的元素正好有n(n+1)/2个，因此，三⾓矩阵可压缩存储到向量s[0..n(n+1)/2]中，其中c存放在向量的最后⼀个分量中================上三⾓矩阵=================以主对⾓线划分，三⾓矩阵有上三⾓和下三⾓两种。
上三⾓矩阵，它的下三⾓（不包括主对⾓线）中的元素均为常数或者0，在⼤多数情况下，三⾓矩阵常数为零。
该图就是⼀个上三⾓矩阵a(m,n)=a(4,4)是⼀个4阶的⽅阵，将该矩阵压缩存储到⼀维数组S后下标012345678910数据12346781112160转换后⼀维数组的长度：S.length=1+n(n+1)/2最后⼀个位置：S[n(n+1)/2]=0其他上三⾓元素的位置在⼀维数组S的下标：S[i(2n-i+1)/2+j-i ]=a(i,j) ;例如 a(2,3)=S[2*(2*4-2+1)/2+3-2]=S[8]=12================下三⾓矩阵=================以主对⾓线划分，三⾓矩阵有上三⾓和下三⾓两种。
数据结构有向图矩阵
数据结构有向图矩阵/********* 所包含的库文件****************************/#include <stdio.h>#include <stdlib.h>#include <string.h>#include <malloc.h>#include <iostream>using namespace std;/********** 宏定义**************************/typedef int ElemType ; /* 元素类型*/typedef int Status ; /* 逻辑形态*/typedef int VRType; /*顶点信息*/typedef int InfoType; /*弧信息*/typedef char VertexType ; /*顶点函数值*/#define OVERFLOW 2 /*益出标志*/#define OK 1 /*代表逻辑*/#define ERROR 0 /*代表逻辑假*//*******************邻接矩阵的存储定义**********************/#define INIFINITY 0 // 最大值#define MAX_VERTEX_NUM 20 //最大顶点数typedef enum {DG,DN,UDG,UDN} GraphKind; //{有向图，有向网，无向图，无向网}typedef struct{int adj; //顶点关系类型无权图1，0 VRType InfoType *info; //弧的相关信息}ArcCell,AdjMatrix[MAX_VERTEX_NUM][MAX_VERTEX_NUM];typedef struct{VertexType vexs[MAX_VERTEX_NUM]; //顶点向量AdjMatrix arcs; //邻接矩阵int vexnum,arcnum; //顶点数和弧的数目GraphKind kind; //图的种类}MGraph; // 图的定义/**********************具体实现**************************///坐落函数int LocateVex(MGraph G,char u){//给出vi求出G中的具体位置int i;for(i=0;i<G.vexnum;i++){ if(u==G.vexs[i]) return i;}if(i==G.vexnum) {printf("Error u!\n"); exit(1);}return 0;}//建无向图(邻接矩阵)Status CreateUDG(MGraph &G) //scanf("%c",&G.vexs[i]);{int w,i,j,k;char v1,v2;printf("请输入矩阵的定点个数和弧数\n");scanf("%d %d",&G.vexnum,&G.arcnum);for(i=0;i<G.vexnum;++i) {printf("请输入顶点字符(列:'v1'(or)'A')\n"); cin>>G.vexs[i]; }//建立顶点向量for(i=0;i<G.vexnum;++i)for(j=0;j<G.vexnum;j++){G.arcs[i][j].adj=INIFINITY;G.arcs[i][j].info=NULL;} //初始默认值for(k=0;k<G.arcnum;++k)//构造邻接矩阵进行{printf("请输入邻接矩阵的关联信息{eg:v1->v2=w(v~顶点w~权值)}\n");cin>>v1>>v2>>w;i=LocateVex(G,v1); j=LocateVex(G,v2); G.arcs[i][j].adj=w; //确定V1,V2在G中的位置//若弧有信息则输入if(IncInfo) Input(*G.arcs[i][j]);}//for kreturn OK;}//CreateUDN//选择建图的类型Status CreateGraph(MGraph &G){int i;printf("请输入你要建的图类型(1~DG~有向图2~DN~有向网3~UDG~无向图4~UDN~有向网)");scanf("%d",&i);G.kind=(GraphKind)(i-1);switch(G.kind){// case DG :return CreateDG(G); //构造有向图G// case DN :return CreateDN(G); //构造有向网Gcase UDG : return CreateUDG(G); //构造无向图G // case UDN :return CreateUDN(G); //构造有向网G default :return ERROR;}}//CreateGraph//图的显示void printf_adjmatrix(MGraph G){int i,j;printf("邻接矩阵:\nvertex\t");for(i=0;i<G.vexnum;i++)printf("%4c",G.vexs[i]);printf("\n");for(i=0;i<G.vexnum;i++){printf("%4c\t",G.vexs[i]);for(j=0;j<G.vexnum;j++){printf("%4d",G.arcs[i][j].adj);}printf("\n");}}//计算顶点的度void Du(MGraph G){int i,j,count1[10]={0},count2[10]={0};for(i=0;i<G.vexnum;i++){for(j=0;j<G.vexnum;j++){if(G.arcs[i][j].adj) {count1[i]++; count2[j]++;} }}printf("a b c d 出度\n");for(i=0;i<4;i++)printf("%d ",count1[i]);printf("\na b c d 入度\n");for(j=0;j<4;j++)printf("%d ",count2[j]);printf("\n");}/***********************图主函数*************************/ void main(){MGraph G;CreateGraph(G);system("cls");printf_adjmatrix(G);Du(G);}。
矩阵及其基本算法
矩阵及其基本算法矩阵是数学和计算机科学中常见的概念，它是由一组数按照固定的行数和列数排列成的矩形阵列。
矩阵在各个领域中具有重要的应用，如代数学、线性方程组的求解、图像处理、数据分析等。
本文将介绍矩阵的基本概念和常见的算法。
1.矩阵的基本概念：-矩阵的行数和列数被称为矩阵的维度。
一个mxn的矩阵有m行n列。
-矩阵元素指的是矩阵中的每个个体数值，可以用a[i][j]表示，其中i表示行数，j表示列数。
-方阵是指行数和列数相等的矩阵，即nxn的矩阵。
-零矩阵是所有元素都是0的矩阵，通常用0表示。
-单位矩阵是一个方阵，其对角线上的元素都是1，其余元素都是0。
2.矩阵的运算：-矩阵的加法：两个相同大小的矩阵相加，即对应位置的元素相加。
-矩阵的减法：两个相同大小的矩阵相减，即对应位置的元素相减。
-矩阵的乘法：两个矩阵相乘，要求左操作数矩阵的列数等于右操作数矩阵的行数。
结果矩阵的行数等于左操作数矩阵的行数，列数等于右操作数矩阵的列数。
乘法运算是对应位置的元素相乘再求和的过程。
-矩阵的转置：将mxn的矩阵转置为nxm的矩阵，即原矩阵的行列互换。
3.矩阵的基本算法：-矩阵的求逆：对于一个可逆矩阵A，存在一个矩阵B，使得A与B的乘积等于单位矩阵。
求逆矩阵的常用方法是高斯-约当消元法。
-矩阵的行列式：行列式是一个与方阵相关的标量，它可以通过递归计算进行求解。
行列式的值可以用于判断矩阵是否可逆，以及计算矩阵的特征值等。
-矩阵的特征值和特征向量：特征值是一个标量，特征向量是与特征值相关联的非零向量。
特征值和特征向量在矩阵的特征值分解、主成分分析等领域有着重要应用。
4.应用实例：-线性方程组的求解：线性方程组可以表示为一个矩阵乘以一个向量的形式，通过求解矩阵的逆，可以得到方程组的解。
-图像处理：图像可以表示为一个像素矩阵，通过对矩阵的像素进行运算，可以实现图像的旋转、缩放、滤波等操作。
-数据分析：矩阵在数据分析中广泛应用，如矩阵分解、矩阵乘法、矩阵求逆等操作可以用于数据降维、主要成分分析、聚类分析等。
数据结构25：矩阵转置算法（三元组顺序表）
数据结构25：矩阵转置算法（三元组顺序表）矩阵的转置实际上就是将数据元素的⾏标和列标互换，即 T(i,j) = M(j,i) 。
例如：图1 矩阵的转置相应地，三元组表转变为：图2 三元组表矩阵的转置，经历了三个步骤：矩阵的⾏数 n 和列数 m 的值交换；将三元组中的i和j调换；转换之后的表同样按照⾏序（置换前的列序）为主序，进⾏排序；实现三元组的转换，重点在第三步，实现算法有两种。
普通算法普通算法的实现过程为：1. 将矩阵的⾏数和列数进⾏调换；2. 遍历表 a 的 j 列（查找 j 的值，从 1 ⼀直到未转置之前的矩阵的列数 m ），遍历的过程，就可以⾃动存储为表 b 的形式。
因为在表 a 中 i 列的数值是从⼩到⼤的，在根据 j 列由上到下的遍历时， i 列同样也是有序的。
实现代码：TSMatrix transposeMatrix(TSMatrix M, TSMatrix T){ //⾏和列置换 T.m = M.n; T.n = M.m; T.num = M.num; if (T.num) { int q = 0; //依次遍历M矩阵的列（从1开始），的遍历的过程中将⾏标和列标置换，得到置换后的三元表T for (int col=1; col<=M.m; col++) { for (int p=0; p<M.num; p++) { if (M.data[p].j == col) { T.data[q].i = M.data[p].j; T.data[q].j = M.data[p].i; T.data[q].data = M.data[p].data; q++; } } } } return T;}此算法的时间复杂度关键在于嵌套的两个 for 循环，时间复杂度为O(m*num)，和矩阵的列数以及⾮ 0 元素的个数的乘积成正⽐，如果稀疏矩阵的⾮ 0 元素很多的情况，使⽤这个算法，虽然⼀定程度上节省了空间，但是时间复杂度会很⾼。
数据结构-稀疏矩阵的三元组表存储方法
0 0 -3 0 0 15
0 12 9 0 0 0 0
12 0 0 0 18 0
00 00000
9 0 0 24 0 0
M= -3 0 0 0 0 14 0 0 0 24 0 0 0 0
求解 N=
0 0 0 0 0 -7 0000 00
0 18 0 0 0 0 0
0 0 14 0 0 0
15 0 0 0 0 0
4 3 24 5 2 18
注意：
data 7 data 8
6 1 15 6 4 -7
mu=6 nu=7 tu=8
为了保存矩阵的行数、列 数和非零元素个数，还需 增设三个量：mu nu tu
3.三元组线性表的数据类型描述
#define MAXSIZE 12500 //非零元素个数的最大值
typedef struct{
稀疏矩阵的压缩存储 ———三元组表
一、什么是稀疏矩阵(sparse matrix)
如果矩阵M中的大多数元素均 为零元素，则称矩阵M为稀疏矩 阵 。一般地，当非零元素个数 只占矩阵元素总数的25%—30%, 或低于这个百分数时，我们称这样 的矩阵为稀疏矩阵。
一、什么是稀疏矩阵(sparse matrix)
3.算法描述
status TransposeSMatrix(TSMatrix a, TSMatrix *b){ (*b).mu=a.nu; (*b).nu=a.mu; (*b).tu=a.tu; if ((*b).tu) { q= 1; for (col= 1 ; col<= a.nu ; + + col) for (p= 1 ; p<= a.tu ; + +p) if (a.data[p] .j = =col) { b.data[q].i=a.data[p] .j; b.data[q].j=a.data[p] .i; b.data[q].e=a.data[p].e; ++q; } return OK;
数据结构 矩阵
数据结构矩阵
矩阵是一种常见的数据结构，它由一组相同类型的元素按照一定的排列方式组成的矩形表格。
矩阵在数学、计算机科学、物理学、统计学等领域有着广泛的应用。
在计算机科学中，矩阵常用于表示图形、图像、网络、关系等数据结构，常见的操作包括矩阵加法、矩阵乘法、矩阵转置、矩阵求逆等。
其中矩阵乘法是最重要的操作之一，因为它在计算机图形学、机器学习、信号处理等领域有着广泛的应用。
矩阵的实现方式有多种，包括二维数组、链表、稀疏矩阵等。
在实际应用中，需要根据不同的应用场景选择不同的实现方式，以达到最优的性能和空间效率。
总之，矩阵是一种重要的数据结构，它在计算机科学和其他领域中有着广泛的应用。
掌握矩阵的基本操作和实现方式，对于提高计算机科学的能力和解决实际问题都有着重要的作用。
- 1 -。
数据结构-稀疏矩阵的三元组表存储方法
a .data 3 3 1 -3
b .data 3 2 1 12
a .data 4 3 6 14 求得 b .data 4 2 5 18
a .data 5 a .data 6 a .data 7
4 3 24
5 2 18 无!
6 1 15
b .data 5 b .data 6 b .data 7
31 9 3 4 24 4 6 -7
b .data 2 1 6 15
a .data 3 3 1 -3
b .data 3 2 1 12
a .data 4 3 6 14 求解 b .data 4 2 5 18
a .data 5 4 3 24
b .data 5 3 1 9
a .data 6 5 2 18
b .data 6 3 4 24
a .data 7 6 1 15
a .data 5 4 3 24
b .data 5
a .data 6 5 2 18
b .data 6
a .data 7 6 1 15
b .data 7
a .data 8 6 4 -7
b .data 8
a. mu=6 a. nu=7 a. tu=8 注:p=1:8,寻找 j=col 的a.data[ p]
a .data 2 1 3 9 Col=6 b .data 2 1 6 15
a .data 3 a .data 4
3 1 -3
b .data 3
3 6 14 求得 b .data 4
2 1 12 2 5 18
a .data 5 4 3 24
b .data 5 3 1 9
a .data 6 5 2 18
2.求解步骤分析：p=1:8, q的值=7
数据结构_图_采用邻接矩阵存储，构造无向图
1.采用邻接矩阵（邻接表）存储，构造无向图（网）输入：顶点数、边数、顶点信息、边信息输出：图的顶点，图的边邻接矩阵（数组表示法）处理方法：用一个一维数组存储图中顶点的信息，用一个二维数组（称为邻接矩阵）存储图中各顶点之间的邻接关系。
假设图G＝(V,E)有n个顶点，则邻接矩阵是一个n×n 的方阵，定义为：如果(vi,vj)属于边集，则edges[i][j]=1，否则edges[i][j]=0。
邻接表存储的处理方法：对于图的每个顶点vi，将所有邻接于vi的顶点链成一个单链表，称为顶点vi的边表（对于有向图则称为出边表），所有边表的头指针和存储顶点信息的一维数组构成了顶点表。
程序代码：#include<iostream>using namespace std;#define MAX_VERTEX_NUM 20 //最大顶点个数#define OK 1typedef int Status;//图的数组（邻接矩阵）存储表示typedef struct ArcCell { // 弧的定义int adj; // VRType是顶点关系类型。
// 对无权图，用1或0表示相邻否；// 对带权图，则为权值类型。
int *info; // 该弧相关信息的指针} ArcCell, AdjMatrix[MAX_VERTEX_NUM][MAX_VERTEX_NUM];typedef struct { // 图的定义char vexs[MAX_VERTEX_NUM];//顶点向量AdjMatrix arcs; // 邻接矩阵int vexnum, arcnum; // 图的当前顶点数、弧数} MGraph;int LocateV ex(MGraph G, char v){int a;for (int i = 0; i <= G.vexnum; i++){if (G.vexs[i] == v)a= i;}return a;}Status CreateUDN(MGraph &G) { //采用邻接矩阵表示法，构造无向网Gint i, j, k, w;char v1, v2;cout <<"输入顶点数，边数："<< endl;cin >> G.vexnum >> G.arcnum;//IncInfo为0,表示各弧无信息cout <<"各顶点分别为："<< endl;for (i = 0; i<G.vexnum; i++)cin >> G.vexs[i]; //构造顶点向量for (i = 0; i<G.vexnum; i++) //初始化邻接矩阵for (j = 0; j<G.vexnum; j++){G.arcs[i][j].adj =NULL;}cout <<"顶点信息、边信息："<< endl;for (k = 0; k<G.arcnum; k++) { //构造邻接矩阵cin >> v1 >> v2 >> w; //输入一条边依附的顶点及权值i = LocateV ex(G, v1); j = LocateV ex(G, v2);G.arcs[i][j].adj = w;G.arcs[j][i] = G.arcs[i][j];} return OK;} //CreateUDN (p162 算法7.2)Status printf1(MGraph G){cout <<"该图的顶点分别为：";for (int i = 0; i<G.vexnum; i++)cout << G.vexs[i] <<"";return OK;}Status printf2(MGraph G){cout <<"该图的边为：";for (int i = 1; i<G.vexnum; i++) //初始化邻接矩阵for (int j = 0; j<i; j++){if (G.arcs[i][j].adj !=NULL)cout << G.vexs[j]<< G.vexs[i] <<"," ;}return OK;}int main(){MGraph G;CreateUDN(G);printf1(G);cout << endl;printf2(G);cout << endl;system("pause");return 0;}。
数据结构程序设计-矩阵的运算
二．概要设计：
1、抽象数据类型定义如下： ADT SparseMatrix{ 数据对象D：D=｛aij|i=1,2,3…,m;j=1,2,3…,n; ai ∈ElemSet,m和n分别称为矩阵的行数和列数｝ 数据关系R： R={Row,Col} Row={<ai,j,ai,j+1>|1≤i≤m, 1≤j≤n-1} Col={<ai,ai+1,j>|1≤i≤m-1, 1≤j≤n} 基本操作 本程序中，用三元组顺序表作为存储结构。 (1)、CreatSMatrix (TSMatrix &M) 操作结果：创建矩阵M。 (2)、AddSMatrix(TSMatrix A,TSMatrix B,TSMatrix &C,int n) 初始条件：矩阵A和B的行数和列数对应相等。 操作结果：求矩阵A、B的和C=A+B。 (3)、SubMatrix (TSMatrix *a,TSMatrix *b) 初始条件：矩阵A和B的行数和列数对应相等。 操作结果：求矩阵A、B的和C=A+B。 (4)、MultiplicationMatrixPow (TSMatrix *a,TSMatrix *b,TSMatrix *c) 初始条件：矩阵A和B的行数和列数匹配 操作结果：求矩阵A、B的和C=A*B。 (5) OutputSMatrix(TSMatrix M) 初始条件：矩阵M已存在 操作结果：输出矩阵M 2、 本程序包含5个模块
for(i=1;i<=M->mu;i++)//输出矩阵 { for(j=1;j<=M->nu;j++) printf("%5d",a[i][j]); printf("\n"); } } //*************矩阵的求和运算*****************// int AddSMatrix(TSMatrix *M,TSMatrix *N,TSMatrix *Q)//求 采用三元组顺序表存储表示的稀疏矩阵M和N的和,结果赋给矩阵Q { int i,j,p,q,x=0,y=0; if((M->mu<=0)||(M->nu<=0)||(M->tu<=0)||(N->mu<=0)||(N>nu<=0)||(N->tu<=0))//判断行数列数非零元素个数是否符合匹配 return ERROR; if(M->mu!=N->mu||M->nu!=N->nu)//判断A与B的行列数 是否相等的 return ERROR; Q->mu=M->mu;//矩阵Q的初始化 Q->nu=M->nu; Q->tu=0; for(i=1;i<=Q->mu;i++) { for(j=1;j<=Q->nu;j++)//寻找矩阵M,N中非零元素相等 的行列 { for(p=1;p<=M->tu;p++)//求矩阵M行列中所对应的 非零元素的值 赋值给X { if((i==M->data[p].row)&&(j==M->data[p].col))// 如果i是矩阵M中非零元素行，j是其列 { x=M->data[p].e;
数据结构-第四章 矩阵的压缩存储.
3
二维数组同样满足数组的定义。一个二维 数组可以被看成是特殊的一维数组，其中， 每个元素又是一个一维数组。多维数组可以 按同样的方法类推。
) )
Amn
( a11 a12 (a 21 a 22 ... ( ... (a m1 a m 2
( ) (
... ... a1n ) ... ... a 2 n ) ... ... ... ) ... ... a mn )
特殊矩阵：值相同的元素或零元素在矩阵中
分布有一定规律。 稀疏矩阵：零元素较多，分布无规律。
11
4.2.1
对称矩阵
Aij Aji
在一个n阶方阵A中，若元素满足下述性质：
则称A为对称矩阵。对称矩阵中的元素关于主 对角线对称，故只需要存储矩阵的上三角或下 三角矩阵，这样可以节约大约一半的空间。
0 0 0 0 0 14 0 0 0 0 0 0 0 0 0 0 67 0 0
col
1 2 1
2 2
3
4 1
5 0
6 1 8
7 0 9
num[col]
cpot[col]
2
5
3
7
8
扫描矩阵三元组表，根据某项的列号，确定它转置 后的行号，查 cpot表，按查到的位置直接将该项存入 转置三元组表中。
7
二维数组与高维数组
1）存储方式
计算机的存储结构是一维的，因而多维数组必须 按某种次序排成一个线性序列加以存储。
a[1][1] a[2][1] A a[3][1] a[m][1]
a[1][2] a[2][2] a[3][2]
a[1][3] a[2][3] a[3][3]
数据结构课程设计矩阵的运算
数据结构课程设计报告题目：专业：班级：学号：姓名：指导老师：时间：一、课程设计题目及所涉及知识点设计题目是“矩阵的运算”，所涉及的知识点主要是：1、数据结构中的对于结构体的定义，用typedef struct来实现，根据所设计的问题在结构体里面定义数据类型及其变量，用define定义数组的大小，然后利用typedef 来实现对于变量的未知类型确定正确的类型。
2、利用数组的形式来储存数据，在实现不同操作过程中，有的用一维结构体数组（三元组顺序表）来存储，有的用二维数组来储存。
3、转置的过程中利用的是快速转置的方法，附设了num和cpot两个辅助变量。
4、矩阵的加法、减法、乘法、逆运算的基本算法方式。
5、通过调用每个函数，来实现每个算法的功能。
二、课程设计思路及算法描述设计思路：1、首先是对于转置的考虑，要运用快速转置的方法实现，必须用三元组顺序表来储存数据，所以在第一个结构体中存在int类型的行数（mu）列数（nu）以及非零元素的个数（tu）；然后第二个结构体中分别有非零元素的行下标（i）、列下标（j）和元素数值（e），最后在第一个结构体中实现对第二个结构体成为数组结构体类型。
2、对于其余加法、减法、乘法和逆运算则是运用另一个结构体来实现，里面只有矩阵的行数、列数和一个二维数组（用float来定义类型）。
3、在main函数里面，来实现对于数据的输入操作，利用if语句进行选择来执行操作，利用do……while语句来实现功能的循环操作。
4、分五个函数调用分别来实现转置、加法、乘法、和逆运算，每个里面都有最终输出结果的方式。
算法1：矩阵的转置输入：mu中存放矩阵的行数，tu存放矩阵的列数，i接收行下标的数值，j接收列下标的数值，e来存储数据。
输出：转置后的新矩阵。
输入两行两列数据，在第二行第一列中有个数据为12，其余都为0，则输出的结果为第一行第二列数据为12，其余为0。
算法2：矩阵的加法运算输入：i中存放矩阵的行数，j中存放矩阵的列数，二维数组b中存放每个数据。
数据结构-)对称矩阵的存储结构
数据结构-)对称矩阵的存储结构数据结构-对称矩阵的存储结构1.简介对称矩阵是指矩阵沿主对角线对称的矩阵。
在存储对称矩阵时，需要考虑节省空间和提高存储与访问效率的问题。
本文将介绍几种对称矩阵的存储结构，包括压缩列存储法、压缩行存储法和按下三角行序存储法。
2.压缩列存储法在压缩列存储法中，对称矩阵按列顺序依次存放，每一列保存一个非零元素的坐标和值。
2.1 数据结构对称矩阵的压缩列存储法可以使用以下数据结构：- 一个一维数组`data`，用于存放非零元素的值。
- 一个一维数组`rowIndex`，用于保存每一列第一个非零元素的行号。
- 一个一维数组`nextIndex`，用于记录下一个非零元素在`data`数组中的位置。
- 一个整数`num`，用于记录非零元素的个数。
2.2 存储过程在进行存储过程时，可以按列顺序遍历对称矩阵，对于每一列的非零元素，将其行号和值分别保存到`rowIndex`和`data`数组中，并更新`nextIndex`记录下一个非零元素的位置。
3.压缩行存储法在压缩行存储法中，对称矩阵按行顺序依次存放，每一行保存一个非零元素的坐标和值。
3.1 数据结构对称矩阵的压缩行存储法可以使用以下数据结构：- 一个一维数组`data`，用于存放非零元素的值。
- 一个一维数组`colIndex`，用于保存每一行最后一个非零元素的列号。
- 一个一维数组`nextIndex`，用于记录下一个非零元素在`data`数组中的位置。
- 一个整数`num`，用于记录非零元素的个数。
3.2 存储过程在进行存储过程时，可以按行顺序遍历对称矩阵，对于每一行的非零元素，将其列号和值分别保存到`colIndex`和`data`数组中，并更新`nextIndex`记录下一个非零元素的位置。
4.按下三角行序存储法按下三角行序存储法是将对称矩阵按行优先的顺序存放，只存储下三角部分的非零元素。
4.1 数据结构对称矩阵的按下三角行序存储法可以使用以下数据结构：- 一个一维数组`data`，用于存放非零元素的值。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
软件学院
上机实验报告
课程名称：数据结构
实验项目：矩阵
实验室：耘慧420
姓名：学号
专业班级：实验时间：2016.11.24 实验成绩评阅教师
一、实验目的及要求
1. 掌握稀疏矩阵压缩存储方法(三元组顺序表存储)。
2. 完成压缩存储下矩阵计算(矩阵转置)。
二、性质
验证性
三、实验学时
2 学时
四、实验环境
C 与C++ 程序设计学习与实验系统
五、实验内容及步骤
实验内容：
1.实现矩阵压缩存储。
(静态数组压缩存储或直接输入矩阵非0 元均可)
2.实现矩阵转置算法。
3.实现矩阵快速转置。
实验步骤：
1.实现矩阵压缩存储。
(静态数组压缩存储或直接输入矩阵非0 元均可)
2. 实现矩阵转置算法TransposeSMatrix(TSMatrix M,TSMatrix &T) 。
3. 实现矩阵快速转置FastTransposeSMatrix(TSMatrix M,TSMatrix &T) 。
4. 主函数中创建矩阵M，将M 调用转置算法转置成矩阵N，调用快速转置算法转化
成矩阵T。
六、实验数据及结果分析
七、总结
了解了矩阵的一些知识，懂得了矩阵的一些算法。
并且在实际上机中，学会了矩阵的程序的编写方法。
附录源程序清单插入; #include<stdio.h>
#include"malloc.h"
#include<conio.h>
#include<stdlib.h>
#define OK 1
#define ERROR 0
#define MAXSIZE 12500
#define MAXRC 1000
typedef int ElemType;
typedef int Status;
typedef struct {
int i,j;
ElemType e;
}Triple;
typedef struct{
Triple data[MAXSIZE+1];
int rpos[MAXRC+1];
int mu,tu,nu;
}RLSMatrix;
Status TransposeSMatrix(RLSMatrix M, RLSMatrix &T){ int q=1,col=0,p=0;
T.mu=M.nu;
T.nu=M.mu;
T.tu=M.tu;
if(T.tu){
q=1;
for(col=1;col<=M.nu;++col)
for(p=1;p<=M.tu;++p)
if(M.data[p].j==col){
T.data[q].i=M.data[p].j;
T.data[q].j=M.data[p].i;
T.data[q].e=M.data[p].e;++q;
}}
return 0;
}
Status FastTransposeSMtrix(RLSMatrix M,RLSMatrix &T){ int col=0,t=0,p=0,q=0;
ElemType num[100],cpot[100];
T.mu=M.nu;
T.nu=M.mu;
T.tu=M.tu;
if(T.tu){
for(col=1;col<=M.nu;++col)num[col]=0;
for(t=1;t<=M.tu;++t)++num[M.data[t].j];
cpot[1]=1;
for(col=2;col<=M.nu;++col) cpot[col]=cpot[col-1]+num[col-1]; for(p=1;p<=M.tu;++p){
col=M.data[p].j;q=cpot[col];
T.data[q].i=M.data[p].j;
T.data[q].j=M.data[p].i;
T.data[q].e=M.data[p].e;
++cpot[col];
}}
return OK;
}
Status CreateSMatrix(RLSMatrix
*M){ int k,m,n,i;
ElemType e;
printf(" 请输入行列非零个数");
scanf_s("%d",&(*M).mu);
scanf_s("%d",&(*M).nu);
scanf_s("%d",&(*M).tu);
(*M).data[0].i=0;
for(i=1;i<=(*M).tu;i++){
do{
printf(" 请输入元素行列元素值");
scanf_s("%d",&m);
scanf_s("%d",&n);
scanf_s("%d",&e);
k=0;
if(m<1||m>(*M).mu||n<1||n>(*M).nu)
k=1;
if(m<=(*M).data[i-1].i&&n<=(*M).data[i-1].j)
k=1;
}while(k);
(*M).data[i].i=m;
(*M).data[i].j=n;
(*M).data[i].e=e;
}
return OK;
}
void printfSMatrix(RLSMatrix
&M){ int i;
printf_s("%4d%4d%8d\n",M.mu,M.nu,M.tu);
for(i=1;i<=M.tu;i++)
printf_s("%4d%4d%8d\n",M.data[i].i,M.data[i].j,M.data[i].e); }
int main(void)
{
RLSMatrix M,N,T,Q;
CreateSMatrix(&M);
FastTransposeSMtrix( M,T);
printfSMatrix(T);
CreateSMatrix(&N);
TransposeSMatrix(M,Q);
printfSMatrix(Q);
_getch();
return 0;
}
Welcome To Download !!!
欢迎您的下载，资料仅供参考！
精品资料。