有向图的转置

最新推荐文章于 2024-07-14 12:25:25 发布
最新推荐文章于 2024-07-14 12:25:25 发布
阅读量1.5k 收藏 5
点赞数 1
分类专栏： Algorithm 文章标签： 算法 数据结构 图论 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51648153/article/details/121943656
版权

        所谓有向图的转置，就是将本该从u指向v的边，修改为v指向u，实现访问方向的倒转，此即为图的转置。（更加学术性的定义参见《算法导论》第四版 p343页 22.1-3）

        由于图的实现方式不同，实现图的转置的方式也不同。图的存储方式主要分为两种，第一种是邻接链表的方式，另外一种是邻接矩阵的方式，前者涉及到大量指针的修改，比较繁琐，后者只涉及到矩阵元素的交换，比较简单。

        下面，分别对两种有向图的转置进行介绍：

一、邻接矩阵的转置 

        图的邻接矩阵表示法是通过一个表示边集是否邻接的二维素组实现的。如果u->v有一条边，那么在邻接矩阵中adj[u][v]=1，反之为0（我们在这里讨论的都是无权图）。

        因此，实现图的转置，只需要将邻接矩阵中u->v和v->u的内容进行交换。例如，u->v有边，而v->u没有边，交换的结果会导致u->v没有边，同时v->u有边，即实现了图的转置。

        这种方法的正确性是毋庸置疑的，但其中有一个小细节值得我们关注。 我们在进行遍历的过程中，实则是在操纵u时就已经同时操纵了v，即我们不再需要访问节点v，如果重复访问，将会导致反转后再反转，即负负得正，没有反转。因此，我们只需要遍历一半矩阵即可，这同时降低了时间复杂度。为O(V^2/2+V)=O(V^2)，其中V表示顶点数，同样也是矩阵的一维规模。

        转置部分代码：

//图的转置 通过交换矩阵下标的方式 （只访问图的一半 否则会导致将修改完的内容又重新转置 复原）
void GraphTrans(Graph graph){
    int size = graph->ver;
    for(int i=0;i<size;i++){
        for(int j=i;j<size;j++){
            //使用交换的方式进行转置
            int temp = graph->Edge[i][j].weight;
            graph->Edge[i][j].weight = graph->Edge[j][i].weight;
            graph->Edge[j][i].weight = temp;
        }
    }
}

        基于C语言实现的图的邻接矩阵表示及转置等操作的完整代码如下：

//
// Created by 周龙 on 2021/12/11.
//

#include <stdlib.h>
#include <stdio.h>
#define MAXSIZE 100
#define INF 12042
//顶点表和边表两个都需要 顶点表用于存放顶点的内容 边表用于修改顶点与边的关系
typedef char Item;
typedef struct{
    Item info[MAXSIZE];
}*Vertex,VertexNode;

typedef struct{
    int weight;
}*Edge,EdgeNode;

//定义图
typedef struct{
    EdgeNode Edge[MAXSIZE][MAXSIZE];//定义矩阵 表示边
    VertexNode Vertex;//顶点数组
    int ver;
}*Graph,GraphNode;

//按图的顶点数量进行初始化
Graph Initial(int ver);

//以给定的顶点修改图
void Create(Graph graph,EdgeNode edge[6][6],int size);

//图的转置
void GraphTrans(Graph graph);

//图的遍历
void Traverse(Graph graph);


//主函数 用于测试
int main() {
    int ver = 6;
    Graph graph = Initial(ver);//有10个顶点
    int Matrix[6][6]={
        {0,1,0,1,0,0},
        {0,0,0,0,0,0},
        {0,1,0,0,1,1},
        {0,1,0,0,0,0},
        {0,1,0,1,0,0},
        {0,1,0,0,0,1}
    };
    EdgeNode edge[6][6];
    for(int i=0;i<6;i++){
        for(int j=0;j<6;j++){
            edge[i][j].weight = Matrix[i][j];
        }
    }
    Create(graph,edge,ver);//根据边集矩阵创建图
    
    printf("Before trans:\n");
    Traverse(graph);//遍历图
    
    GraphTrans(graph);//图的转置
    
    putchar('\n');
    printf("After trans:\n");

    Traverse(graph);

    return 0;
}




//图的转置 通过交换矩阵下标的方式 （只访问图的一半 否则会导致将修改完的内容又重新转置 复原）
void GraphTrans(Graph graph){
    int size = graph->ver;
    for(int i=0;i<size;i++){
        for(int j=i;j<size;j++){
            //使用交换的方式进行转置
            int temp = graph->Edge[i][j].weight;
            graph->Edge[i][j].weight = graph->Edge[j][i].weight;
            graph->Edge[j][i].weight = temp;
        }
    }
}


//按图的顶点数量进行初始化
Graph Initial(int ver){
    Graph graph = (Graph)malloc(sizeof(GraphNode));
    graph->ver = ver;
    for(int i=0;i<ver;i++){
        graph->Vertex.info[i] = (char)((int)'a'+i);
        for(int j=0;j<ver;j++){
            graph->Edge[i][j].weight = 0;//置为0 表示全都没有边
        }
    }
    return graph;
}

//以给定的边集关系修改图
void Create(Graph graph,EdgeNode edge[6][6],int size){
    for(int i=0;i<size;i++){
        for(int j=0;j<size;j++){
            graph->Edge[i][j] = edge[i][j];
        }
    }
    graph->ver = size;
}



//图的遍历
void Traverse(Graph graph){
    int size = graph->ver;
    for(int i=0;i<size;i++){
        for(int j=0;j<size;j++){
            if(graph->Edge[i][j].weight!=0){
                printf("%c -> %c\n",graph->Vertex.info[i],graph->Vertex.info[j]);
            }
        }
    }
}

        代码运行结果：

        可见，曾经顺序的关系都已经被逆转了。 

二、邻接表的转置 

        除了上述的使用邻接矩阵表示的边集数组表示图之外，还可以借助链表表示图这一数据结构。维护一个顶点数组，其含有一个next指针，指向其边集。如果存在边，则向顶点数组的next中插入一个节点，即形成边集。

        由于这些节点都是已经创建好的，因此我们在进行转置的时候只需要更改指向就可以了。更改过指向的节点要进行标记（本文中在边集中添加IsReverse进行标记），防止对一个节点进行多次反转，同样会导致负负得正，即没有修改。

        转置部分代码如下：


//反转链表
void Reverse(Graph graph) {
	/*
	* 由于边表都是已经分配的内存 只修改链接即可
	* 可以使用visit来标记是否已经被转置 但比较麻烦
	* 对于转置后的边和原有相同指向的边不易辨别
	* 考虑在edge中加入IsReverse来判断一个节点是否被反转过了
	* 每次删除在头部O(1) 每次插入在中部O(V) 这个时间复杂度值得好好讨论
	* 时间复杂度大约为O(V+E) 不是特别准确
	*/
	int buf[graph->v][graph->v];
	for (int i = 0; i < graph->v; i++) {
		for (int j = 0; j < graph->v; j++) {
			buf[i][j] = 0;//表示u v 节点已经被转置了 不需要重复转置
		}
	}
	for (int i = 0; i < graph->v; i++) {
		Edge temp = graph->vertex[i].next;
		while (temp) {
			//temp就是待转置的节点
			if (temp->IsReverse) {
				//如果节点已经是被转置过了 则无需转置 且转置完成
				break;
			} else {
				int v = temp->v;
				temp->v = temp->u;
				temp->u = v;
				
				//修改顶点的指向
				graph->vertex[i].next = temp->next;
				//将节点插入
				temp->IsReverse = 1;
				temp->next = NULL;//避免重复指向
				InsertNode(graph, temp);
			}
			temp = graph->vertex[i].next;
		}
	}
}


//向反转链表中插入节点
void InsertNode(Graph graph, Edge edge) {
	int u = edge->u;
	//转置 将该边插入到ver[u]上 u、v已经转置修改过
	if (!graph->vertex[u].next||graph->vertex[u].next->IsReverse) {
		edge->next = graph->vertex[u].next;//和该边的尾部链接
		graph->vertex[u].next = edge;//指向该边
	} else {
		Edge temp = graph->vertex[u].next;
		//如果被反转过 则直接插入即可
		while (temp->next&&!temp->next->IsReverse) {
			temp = temp->next;
		}
		edge->next = temp->next;//链接尾部
		temp->next = edge;//插入尾部
	}
}

        基于C语言实现图的邻接矩阵表示方式及图的转置等操作的完整代码如下：

#include <stdio.h>
#include <stdlib.h>

//反转链表
typedef _Bool bool;
enum Color{
	White,Gray,Black
};
//图的邻接表表示方法
//边集
typedef struct edge{
	int weight;//权重
	//边u、v
	int u;//从u起
	int v;//到v止
	struct edge*next;//邻接的边
	int IsReverse;
}EdgeNode,*Edge;

//顶点集
typedef struct{
	int color;//颜色 用于在DFS中判断有无后向边
	int u;//顶点下标
	Edge next;//指向边集的指针
	int d;
}VertexNode,*Vertex;

//定义图
typedef struct{
	int v;
	int e;
	Vertex vertex;//顶点集
}GraphNode,*Graph;


//图的初始化 以ver为点集 以edge为边集
Graph Initial(int ver);

//向图中插入边 建立图
bool Insert(Graph graph,Edge node);

//向待逆转的表中插入该逆转的节点
void InsertNode(Graph graph,Edge edge);

void Reverse(Graph graph);//有向图的转置

//深度优先遍历
void DepthFirstSearch(Graph graph);

//深度优先遍历的递归辅助函数
void DFS_AUX(Graph graph,Vertex node);


int main() {
	int ver = 5;//顶点数为5
	Graph graph = Initial(ver);//初始化graph
	Edge *node = (Edge*)malloc(sizeof(Edge)*ver*2);//分配节点
	
	//插入邻接边集 构造形如0->1->2->3->4的有向图 或者无向图
	for(int i=0;i+1<ver;i++){
		node[i] = (Edge) malloc(sizeof(EdgeNode));
		node[i]->u=i;node[i]->v=i+1;node[i]->next=NULL;
		Insert(graph,node[i]);
		//这里如果注释掉就构造有向图 如果解除注释就是无向图
		//node[i+1] = (Edge) malloc(sizeof(EdgeNode));
		//node[i+1]->u=i+1;node[i+1]->v=i;node[i+1]->next=NULL;
		//Insert(graph,node[i+1]);
	}

	printf("----------------\n");
	printf("DFS:\n");
	DepthFirstSearch(graph);//深度优先搜索 
	
	//反转图的邻接矩阵
	Reverse(graph);
	printf("\nAfter Reverse:\n");
	printf("----------------\n");
	printf("DFS:\n");
	
	DepthFirstSearch(graph);
	return 0;
}


//反转链表
void Reverse(Graph graph) {
	/*
	* 由于边表都是已经分配的内存 只修改链接即可
	* 可以使用visit来标记是否已经被转置 但比较麻烦
	* 对于转置后的边和原有相同指向的边不易辨别
	* 考虑在edge中加入IsReverse来判断一个节点是否被反转过了
	* 每次删除在头部O(1) 每次插入在中部O(V) 这个时间复杂度值得好好讨论
	* 时间复杂度大约为O(V+E) 不是特别准确
	*/
	int buf[graph->v][graph->v];
	for (int i = 0; i < graph->v; i++) {
		for (int j = 0; j < graph->v; j++) {
			buf[i][j] = 0;//表示u v 节点已经被转置了 不需要重复转置
		}
	}
	for (int i = 0; i < graph->v; i++) {
		Edge temp = graph->vertex[i].next;
		while (temp) {
			//temp就是待转置的节点
			if (temp->IsReverse) {
				//如果节点已经是被转置过了 则无需转置 且转置完成
				break;
			} else {
				int v = temp->v;
				temp->v = temp->u;
				temp->u = v;
				
				//修改顶点的指向
				graph->vertex[i].next = temp->next;
				//将节点插入
				temp->IsReverse = 1;
				temp->next = NULL;//避免重复指向
				InsertNode(graph, temp);
			}
			temp = graph->vertex[i].next;
		}
	}
}


//向反转链表中插入节点
void InsertNode(Graph graph, Edge edge) {
	int u = edge->u;
	//转置 将该边插入到ver[u]上 u、v已经转置修改过
	if (!graph->vertex[u].next||graph->vertex[u].next->IsReverse) {
		edge->next = graph->vertex[u].next;//和该边的尾部链接
		graph->vertex[u].next = edge;//指向该边
	} else {
		Edge temp = graph->vertex[u].next;
		//如果被反转过 则直接插入即可
		while (temp->next&&!temp->next->IsReverse) {
			temp = temp->next;
		}
		edge->next = temp->next;//链接尾部
		temp->next = edge;//插入尾部
	}
}




//图的初始化 以ver为点集 以edge为边集
Graph Initial(int ver) {
	if (ver <= 0) {
		fprintf(stderr, "Invalid vertex number.\n");
		return NULL;
	}
	Graph graph = (Graph) malloc(sizeof(GraphNode));//创建图
	graph->v = ver;
	graph->e = 0;//没有边
	graph->vertex = (Vertex) malloc(sizeof(VertexNode) * ver);
	for (int i = 0; i < ver; i++) {
		graph->vertex[i] = (VertexNode) {White, i, NULL};
		graph->vertex[i].next = NULL;
		graph->vertex[i].color = White;
	}
	return graph;
}



//向图中插入边 建立图
bool Insert(Graph graph, Edge node) {
	//直接头插即可
	if (node == NULL) {
		fprintf(stderr, "The node is null\n");
		return 0;
	}
	if (node->u < 0 || node->u >= graph->v || node->v < 0 || node->v >= graph->v) {
		fprintf(stderr, "Invalid index of vertex\n");
		return 0;
	}
	int index = node->u;
	node->IsReverse = 0;//未被逆转
	graph->e++;
	node->next = graph->vertex[index].next;
	graph->vertex[index].next = node;
	
	return 1;
}


//深度优先遍历
void DepthFirstSearch(Graph graph) {
	//对所有的节点着色
	int size = graph->v;//顶点数
	for (int i = 0; i < size; i++) {
		graph->vertex[i].color = White;//着白色
	}
	for (int i = 0; i < size; i++) {
		if (graph->vertex[i].color == White) {
			DFS_AUX(graph, &graph->vertex[i]);
			printf("\n");
		}
	}
}

//标定从哪个顶点开始访问 顶点表和边表
void DFS_AUX(Graph graph, Vertex node) {
	//处理第一次访问的节点
	node->color = Gray;//着为灰色
	printf("%d ", node->u);
	//开始遍历其邻接的节点作为子树的根
	Edge temp = node->next;
	while (temp) {
		//避免重复访问
		if (graph->vertex[temp->v].color == White) {
			DFS_AUX(graph, &graph->vertex[temp->v]);//递归地访问
		}
		temp = temp->next;
	}
	node->color = Black;
}

        运行结果如下： 

       

      可以看到，在反转前的DFS能够按0->1->2->3->4的方式访问到链表，反转后，由于0->1的边被反转，不存在有效的边，所以只能以0-4为根生成多个连通子图。可见，我们真的实现了图的转置。

        欢迎大家指正！

小北和小文
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
反转有向图
miaochengshi的博客
12-08 903
Reverse a Directed Graph 反转有向图 问题描述 给定一个有向图，反转图的边并输出。 测试样例 # Input: A -> B, B -> C, A ->C # Output: B->A, C -> B, C -> A 内容首发于微信公众号IT信息教室，如果您想学习更多AI相关的技能，欢迎搜索关注或微信扫描下方二维码关注～～ 参考代码 #!/usr/bin/env python3 # -*- coding: utf-8 -*- # -----
直方图的转化
hahahanba的博客
03-14 352
直方图 问题描述：读取图像，然后图像的直方图进行归一化与均衡化。 归一化 归一化直方图的操作被称作灰度变换（Grayscale Transformation）。它描述的是像素点取值范围从[c,d][c,d][c,d]转换到[a,b][a,b][a,b]的过程。下面我们将imori_dark.jpeg的灰度扩展到[0,255][0, 255][0,255]范围： xout={a(ifxin<c)b−ad−c (xin−c)+a(else ifc≤xin<d)b(else) x
有向图和双随机转移矩阵关系的探讨
weixin_30610755的博客
05-11 1214
When does a digraph admit a doubly stochastic adjacency matrix Doubly Stochastic: 对于每一个节点，如果输入权重和输出权重都等于1，那么就是双随机的有向图。简而言之，如果允许双重随机邻接矩阵的有向图，称为具有双重随机性质。 双重随机性是图中非常良好的性质，并以此展开大量的研究。事实上，这种要求还是比较苛刻的，因此...
【矩阵】将有向图转化为矩阵的应用
EnjoyingAC的博客
05-26 2886
任务 给定一个有向图（可以有环），求从A点恰好走n步（可以重复经过边）到达B点的方案总数。 图与邻接矩阵 数据结构中学过图的邻接矩阵表示，m[i][j]=1表示存在有向边（i，j），m[i][j]=0表示不存在该边。 解题 假设图有三个结点A，B，C。图的邻接矩阵表示为 A 1 0 1 B 0 0 1 C 1 1 1 求A到B恰好从2步的方案有： A–&amp;amp;gt;A–&amp;amp;gt;B ...
图论-关联矩阵
jiahonghao2002的博客
01-26 2180
图论-关联矩阵 问题 有向无环图G=(V,E)G=(V,E)G=(V,E)的关联矩阵是满足下述条件的∣V∣×∣E∣|V| \times |E|∣V∣×∣E∣矩阵B=(bij)B=(b_{ij})B=(bij​)。 bij={−1如果边j从节点i出发1如果边j进入节点0其他 b_{ij} = \left\{\begin{matrix} & -1 & 如果边j从节点i出发 \\ & 1 & 如果边j进入节点 \\ & 0 & 其他 \end{matr
邻接矩阵A和A的转置矩阵乘积表示的意义(有向图)
修也
10-30 8717
A:矩阵 AT:A的转置矩阵 A*AT 对角线上的表示 顶点vi的出度 AT*A 对角线上的表示 顶点vi的入度
图形算法与实战：6.图像运动专题（4）图像转置
进击的CV
06-28 891
图像运动专题-图像转置 目录 图像运动专题-图像转置 1. 图像处理前后结果展示 图像处理前 图像处理后 2.几何平移原理 3.代码展示 1. 图像处理前后结果展示 图像处理前 图像处理后 2.几何平移原理 一幅图像的转置是指将图像像素的x坐标和y坐标互换，相应的转置后图像的宽度与长度会随之互换。 图像转置指的是将图像像素的x坐标和y坐标进行互换，其变换的公式可用如下的形式表示： 转置变换的坐标图如下图所示， ...
数字图像处理_matlab_转置_平移_缩放_镜像变换_
10-03
假设我们想要将图像向右移动`dx`像素，向下移动`dy`像素，代码可能是这样的：`I_translated = imtranslate(I, [dx, dy])`。平移操作常用于图像对齐或去除背景噪声。 3. 图像缩放： 图像缩放改变图像的尺寸，可以...
VC 图像几何变换、图像平移、垂直水平镜像、图像转置、图像缩放、图像旋转
03-20
例如，对于水平镜像，可以将每一行的像素从右向左复制；对于垂直镜像，则将每一列的像素自下而上复制。 **图像转置**，又称为图像翻转或转90度，是沿着主对角线翻转图像的过程。这相当于将图像的行和列互换。在VC中...
c语言数据结构 矩阵的转置
05-31
在C语言中，数据结构是程序设计的重要组成部分，它涉及如何高效地组织和处理数据。...在实际编程中，理解数据结构如矩阵以及如何在C语言中操作它们是至关重要的，这有助于编写出更加高效和灵活的代码。
kosaraju:Kosaraju 算法是一种线性时间算法，用于查找有向图的强连通分量
07-13
kosaraju 算法Kosaraju 算法是一种线性时间算法，用于查找有向图的强连通分量算法Kosaraju 算法的工作原理如下： 设 G 为有向图，S 为空栈。 虽然 S 不包含所有顶点： 选择不在 S 中的任意顶点 ''v''。从 ''v'' 开始...
C++实现图像几何变换
11-06
例如，如果要将图像向右移动tx个像素，向下移动ty个像素，我们可以对每个像素的坐标(x, y)进行以下变换： ```cpp int newX = x + tx; int newY = y + ty; ``` 然后，使用新的坐标读取或写入像素值。 ### 旋转 ...
求有向图G的转置图GT
weixin_33966095的博客
07-15 1728
有向图G=（V，E）的转置是图GT=(V，ET)，其中边&lt;u，w&gt;∈ET当且仅当&lt;w，u&gt;∈E，即GT就是G的所有边反向所组成的图。请按照相邻矩阵和邻接表两种表示法写出从G计算GT的有效算法，并确定算法的时间代价。 相邻矩阵 #include &lt;stdio.h&gt; #define MAX_VALUE 0//当两个点不相连是路径的权为0 #define MAX_NU...
pytorch geometric中为何要将稀疏邻接矩阵写成转置的形式adj_t
weixin_39925939的博客
11-15 5858
pytorch geometric中为何要将稀疏邻接矩阵写成转置的形式adj_t
D - Silver Cow Party(dijstra+矩阵转置）
nuoyanli的博客
04-09 3321
题目来源： https://vjudge.net/contest/290751#problem/D One cow from each ofNfarms (1 ≤N≤ 1000) conveniently numbered 1..Nis going to attend the big cow party to be held at farm #X(1 ≤X≤N). A tot...
【算法导论】22.1 图的转置
Harry的专栏
11-18 2286
用邻接表表示的图的转置算法，比较简单。 #include using namespace std; #define N 8 #define INFINITE 0x7fffffff #define WHITE 1 #define GRAY 2 #define BLACK 3 //顶点结点结构 struct Vertex { Vertex * next;/*指向下一个顶点*/
《算法导论》习题解答 Chapter 22.1-3（转置图）
weixin_30859423的博客
07-16 271
一、邻接表实现 思路：一边遍历，一边倒置边，并添加到新的图中 邻接表实现伪代码： for each u 属于 Vertex for v 属于 Adj[u] Adj1[v].insert(u); 复杂度：O(V+E); 输入： 3 3 a b b c c a 源代码： package C22; import java.util.Iterator...
算法014：找到字符串中所有字母异位词
最新发布
m0_62319039的博客
07-14 282
算法014：找到字符串中所有字母异位词

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值