欧拉路径的Fleury算法-C 语言实现

已于 2023-02-14 20:06:33 修改
阅读量1.3k 收藏 14
点赞数 1
文章标签： 算法 c语言 深度优先
于 2023-02-14 20:04:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Jasonchen1224/article/details/129032732
版权
本文详细介绍了Fleury算法在寻找无向连通图的欧拉路径中的应用，该算法基于深度优先遍历，重点在于判断和处理桥边。通过从具有奇数度的顶点出发，选择非桥边进行遍历，逐步构建欧拉路径。文章提供了C语言实现的函数接口，并强调了算法中回溯和恢复边的重要性。
摘要由CSDN通过智能技术生成

欧拉路径的Fleury算法-C语言实现

我们前面介绍了Hierholzer算法求解有向连通图的欧拉路径（欧拉回路）的算法，这个算法可以简单理解为环环相连，最终求得欧拉路径，整个过程利用深度优先遍历思想，以图中的边为遍历对象，完成遍历后即可求得相应的欧拉路径（欧拉回路），这个算法逻辑清晰，程序运行效率较高。

本文将介绍另外一种欧拉路径的算法，终点介绍无向连通图中的欧拉路径，主要算法为Fleury算法，此算法的核心思想为，如果现有顶点点的度为1，那么和此度相关的唯一路径标记为有效路径，Fleury算法可以立即进行处理；否则就需要利用类似回溯的思想，来评估这些路径是否为bridge. 那么问题就来了，如何定义某顶点到另外一个顶点的路径为bridge呢？

思路很简单，我们先从某顶点(v)出发，评估此顶点直接或间接可达(reachable)的顶点数目，记为count1; 然后我们评估(v,w)是否为桥，这时候，我们在图中先移除此边，如果顶点(v)可达的定点数量count2比count1要小，那么(v,w)就成为一桥边(bridge edge)。无论此边是否为桥边，我们再操作后，都需要把这条边重新加入到图中去。是否不是听起来有点熟悉，这就是回溯的经典思想，后面就这个问题我们在程序中将进一步展开。

一图胜千言，我们借助一张图，来对上面的桥边进行进一步的理解。

在这里插入图片描述

读者先暂停几秒，思考一下，如果此图中存在欧拉路径（欧拉回路），起点是哪个？ 显而易见，我们应该从C或D出发，才能完成欧拉路径的搜索，起点位置的选择是欧拉路径的性质决定的，只能从奇数点出发（如果是欧拉路径而不存在欧拉回路）。在上图中，如果从C定点出发，我们可以有3个选择，可以选择(C,D)、(C,A)、（C,B)，针对这三个选择，我们如何判断哪条边是正确的选择呢（非桥边）。我们利用回溯方法逐一判断知道找到一条非桥边。

如果第一步，我们尝试选择（C,D), 我们从C点出发，在保持（C,D)边的前提下，利用DFS对顶点进行深度优先遍历，得到count 1=4(包括C顶点本身)；然后我们尝试从无向图中移除（C,D)边，移除后的D顶点变为孤岛。如果再次从C点开始进行DFS深度优先搜索，我们容易得到count2=3。由于移除(C,D)后，从C点能到达的顶点数量减少，那么我们就认为(C,D)为桥边。

在这里插入图片描述

值得注意的是，我们再尝试两次DFS遍历顶点后，需要回复之前移除的边，以便后续能继续访问。恢复边后的图如下：

在这里插入图片描述

我们可以尝试评估(C,A)是否为桥边，同理，我们先从C点出发对图上的顶点进行DFS遍历，遍历完成后得到count1=4; 然后，我们尝试去掉(C,A)边，再次进行DFS对顶点的遍历，我们得到count2=4; 由于两次遍历的定点数没有减少，所以我们可以判断(C,A)为非桥边。也就是，我们即使再Fleury算法中真正删除(C,A)后，仍然可以通过其他路径回到C点。

Fleury思想的特点之一，如果每个顶点关联多条路径，在跨出每一步之前，都要确保即使断了这条路，也有可能回到原来的顶点，真正做到即使“过河拆路”，也可能回到原点。

我们回到主题，现在我们解决了桥边的判断问题，如果顶点关联的边多余1条，我们总是从非桥边开始往前遍历。关于桥边的阐述我们可以暂时告一段路，我们接下来就要回到Fleury算法本身。

Fleury算法的核心思想为，找到一条非桥边或独边，以边为遍历对象，逐边进行DFS遍，遍历后，把此边删除（真正删除)。不断利用DFS对边进行遍历，直至遍历结束。

接下来，我们谈一下算法的实现，我们在算法中采用C语言和严蔚敏《数据结构》中的邻接矩阵：

a) 函数的头文件说明(Euler_Path.h)：

/**
 * @file Euler_Path.h
 * @author your name (you@domain.com)
 * @brief 
 * @version 0.1
 * @date 2023-02-11
 * 
 * @copyright Copyright (c) 2023
 * 
 */
#ifndef EULER_PATH_H
#define EULER_PATH_H
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include "../00_introduction/Status.h"
#include "../01_Matrix_Graph/MatrixGraph.c"


 

/**
 * @brief Find the Euler path(circuit) in the graph
 *
 * @param G Matrix Graph
 * @param path Store the Euler index
 * @param degree Degree of each node in the undirected graph
 * 
 * @return Status -return error if there is Eurler path or circuit
 */
Status find_Euler_Path(MGraph *G, int *path,int *degree);


/**
 * @brief Count the degree of each node
 * 
 * @param G MGraph G
 * @param degree Degree array list
 */
void count_Degree(MGraph G, int *degree);

/**
 * @brief Check if the graph contains Euler path or not
 * @param G MGraph G
 * @param degree Degree array for each node

 * @return true if graph contains Euler path
 * @return false if graph doesn't contain Euler path
 */
bool is_Euler_Path(MGraph G,int *degree);

/**
 * @brief Find the start node in the graph according to the Euler path characteristic
 *
 * @param G Matrix graph
 * @param list Euler_list
 * @return int -Node index
 */
int find_Start_Node(MGraph G, int *degree);

/**
 * @brief Use depth first search to work out the Euler path/circuit
 *
 * @param s Start point
 * @param list Node property array
 * @param path Store the Euler path array
 */
void DFS_Euler(MGraph *G, int s, int *path,int *degree);

/**
 * @brief  This function returns count of vertices reachable from v. 
 * It does DFS
 *
 * @param G Matrix graph
 * @param u Start point
 * @return int Return the count of vertices reachable from v
 */
int DFS_Count(MGraph G, int u);

/**
 * @brief Add the (v,w) edge to Graph
 * 
 * @param G Pointer to Matrix Graph
 * @param v Vertex point 1
 * @param w Vertex point 2
 */
void Add_Edge(MGraph *G, int v, int w,int *degree);

/**
 * @brief Remove the (v,w) edge to Graph
 *
 * @param G Pointer to Matrix Graph
 * @param v Vertex point 1
 * @param w Vertex point 2
 */
void Remove_Edge(MGraph *G,int v, int w,int *degree);

/**
 * @brief Check if the (v,w) is a valid arc(not a bridge)
 * 
 * @param G Pointer to Matrix graph
 * @param v Vertex v
 * @param w Vertex w
 * @return true If not a bridge, return true
 * @return false If a bridge ,return false
 */
bool isValidEdge(MGraph *G,int v,int w,int *degree);

/**
 * @brief Show Euler path
 * 
 * @param G Matrix Graph
 * @param path Path array
 */
void show_EulerPath(MGraph G, int *path);

/**
 * @brief Initialize the degree and path
 *
 * @param G Matrix Graph
 * @param degree Degree of each node in the undirected graph
 * @param path Store the path index of Euler path
 */
void Init_Param(MGraph G, int **degree,int **path);

#endif

b) 函数的实现(Euler_Path.c)

/**
 * @file Euler_Path.c
 * @author your name (you@domain.com)
 * @brief 
 * @version 0.1
 * @date 2023-02-11
 * 
 * @copyright Copyright (c) 2023
 * 
 */
#ifndef EULER_PATH_C
#define EULER_PATH_C
#include "Euler_Path.h"

Status find_Euler_Path(MGraph *G, int *path, int *degree)
{
    int s;

    count_Degree(*G,degree);

    if(!is_Euler_Path(*G,degree))
    {
        return ERROR;
    }

    s = find_Start_Node(*G,degree);
    DFS_Euler(G,s,path,degree);

    return OK;
}

void count_Degree(MGraph G, int *degree)
{
    int i; //row indicator
    int j; //column indicator

    for(i=0;i<G.vexnum;i++)
    {
        
        for(j=0;j<G.vexnum;j++)
        {
            if(G.arcs[i][j].adj)
            {
                degree[i]++;
            }
        }
    }

    return;
}

bool is_Euler_Path(MGraph G, int *degree)
{
    int i;
    int odd_degree;

    odd_degree=0;

    for(i=0;i<G.vexnum;i++)
    {
        if(degree[i]%2!=0)
        {
            odd_degree++;
        }
    }

    return (odd_degree==0) || (odd_degree==2);
}

int find_Start_Node(MGraph G, int *degree)
{
    int start;
    int i;

    start=0;

    for(i=0;i<G.vexnum;i++)
    {
        if (degree[i] % 2 != 0)
        {
            start=i;
            break;
        }
    }

    return start;
}


void DFS_Euler(MGraph *G, int s, int *path, int *degree)
{
    int v;
    int w;
    static int index=0;
    v = s;
    
    *(path+index)=v;
    index=index+1;

    for (w = FirstAdjVex(*G, G->vexs[v]); w >= 0; w = NextAdjVex(*G, G->vexs[v], G->vexs[w]))
    {
        if (isValidEdge(G, v, w, degree))
        {
            Remove_Edge(G, v, w, degree);
            DFS_Euler(G, w, path, degree);
        }
    }

}

int DFS_Count(MGraph G, int u)
{
    int count;
    int v;
    int w;

    visited[u]=1;
    count=1;
    v=u;

    for (w = FirstAdjVex(G, G.vexs[v]); w >= 0; w = NextAdjVex(G, G.vexs[v], G.vexs[w]))
    {
        if(!visited[w])
        {
            count=count+DFS_Count(G,w);
        }
    }

    return count;
}

void Add_Edge(MGraph *G, int v, int w,int *degree)
{
    G->arcs[v][w].adj=1;
    G->arcs[w][v].adj=1;
    degree[v]++;
    degree[w]++;
    return;
}

void Remove_Edge(MGraph *G, int v, int w,int *degree)
{
    G->arcs[v][w].adj=0;
    G->arcs[w][v].adj=0;
    degree[v]--;
    degree[w]--;
    return;
}

bool isValidEdge(MGraph *G, int v, int w, int *degree)
{
    int count1; //before (v,w) is removed in the graph
    int count2; //after (v,w) is removed in the graph

    count1=0;
    count2=0;

    if(degree[v]==1)
    {
        return true;
    }

    memset(visited,0,sizeof(int)*MAX_VERTEX_NUM);
    count1=DFS_Count(*G,v);

    Remove_Edge(G,v,w,degree);

    memset(visited, 0, sizeof(int) * MAX_VERTEX_NUM);
    count2=DFS_Count(*G,v);

    Add_Edge(G,v,w,degree);

    return count1<=count2;
}

void show_EulerPath(MGraph G, int *path)
{
    int i;
    for(i=0;i<G.arcnum+1;i++)
    {
        printf("-%c-",G.vexs[path[i]]);
    }

    printf("\n");
}

void Init_Param(MGraph G, int **degree, int **path)
{
    *degree=(int *)malloc(sizeof(int)*G.vexnum);
    *path = (int *)malloc(sizeof(int) * (G.arcnum+1));

    memset(*degree,0,sizeof(int)*G.vexnum);
    memset(*path, 0, sizeof(int) * (G.arcnum + 1));

    return;
}

#endif

c) 主函数和测试(Euler_Path_main.c)

/**
 * @file Euler_Path_main.c
 * @author your name (you@domain.com)
 * @brief 
 * @version 0.1
 * @date 2023-02-12
 * 
 * @copyright Copyright (c) 2023
 * 
 */
#ifndef EULER_PATH_MAIN_C
#define EULER_PATH_MAIN_C
#include "Euler_Path.c"

int main(void)
{
    int *path;
    int *degree;
    MGraph G;
    FILE *fp;


    fp=fopen("UDG.txt","r");
    CreateGraph(&G,fp);

    Init_Param(G,&degree,&path);

    find_Euler_Path(&G,path,degree);

    show_EulerPath(G,path);
    
    PressEnter;
    return EXIT_SUCCESS;
}

#endif

总结，本文的算法略显复杂，但是对DFS的深入理解很有帮助，建议读者能根据Fleury算法原理，尝试自己动手，实现此算法。

以上，
谢谢

参考

  1. 严蔚敏《数据结构》
  2. Eulerian path and circuit for undirected graph
Jasonchen1224
关注
Fleury算法求欧拉回路(一)
神一样少年的博客
09-27 2万+
求解欧拉回路，是《离散数学》中的一个算法，一共有两种算法，一种是Fleury算法，另外一种是逐步插入回路法， 本文讲的是Fleury算法，是一个教你如何用最简单的数组去实现这个算法，代码中没有任何的栈或队列，也没有递归， 告诉你如何用循环来解决这个问题
fleury求欧拉环游算法 matlab,Fleury算法求欧拉路径
weixin_36400198的博客
03-17 1228
分析：小Ho：这种简单的谜题就交给我吧！小Hi：真的没问题么？<10分钟过去>小Ho：啊啊啊啊啊！搞不定啊！！！骨牌数量一多就乱了。小Hi：哎，我就知道你会遇到问题。小Ho：小Hi快来帮帮我！小Hi：好了，好了。让我们一起来解决这个问题。小Hi：原来是这样。。。小Ho你仔细观察这个例子：因为相连的两个数字总是相同的，不妨我们只写一次，那么这个例子可以写成：3-2-4-3-5-1。6个数...
Fleury(佛罗莱)算法
weixin_43244265的博客
10-01 5729
https://blog.csdn.net/NOIAu/article/details/78203851
求欧拉回路,Fleury算法的C语言实现
09-20
可以证明,当算法停止时所得的简单回路Wm=v0e1v1e2….emvm(vm=v0)为G中的一条欧拉回路，复杂度为O(e*e)……
图-欧拉图(欧拉环游 回路、欧拉迹 通路、Hierholzer算法、Fleury算法)_欧拉环游算法
最新发布
2401_85236365的博客
07-21 886
因为存在死胡同（运行过程中先遍历某个点，这个点通过入边遍历后删除入边没有出边了，但是图中还有边没有遍历）但其实应该是a->b->a->c。通过图中每条边且行遍所有顶点的迹（每条边恰一次的途径），称为欧拉迹（Euler trail）。具有欧拉通路但不具有欧拉回路的无向图称为半欧拉图，有且仅有两个度数为奇数的结点。不使用栈，若a为起点，遍历哪个点就加入某数据结构（例如队列 ），先遍历c。一个图若包含欧拉环游，则称为欧拉图(Euleriangraph)。寻找半欧拉图、欧拉图的欧拉迹、欧拉环游/回路。
Fleury（弗罗莱）算法求欧拉回路
weixin_30563917的博客
02-25 256
转自http://www.cnblogs.com/Lyush/archive/2013/04/22/3036659.html 上面是摘自图论书上的定义。 算法在运行过程中删除了所有已走的路径，也就是说途中残留了所有没有行走的边。根据割边的定义，如果在搜索过程中遇到割边意味着当前的搜索路径需要改进，即提前输出某一个联通子集的访问序列，这样就能够保证访问完其中联通子图中后再通过割边访问后一个联...
欧拉回路的Fleury算法
06-26
图论——欧拉回路的Fleury算法 根据离散数学教材中思想 实现求欧拉回路。
数据结构与算法分析-C++描述 第9章 图论算法（欧拉回路问题之Fleury算法）
qq_37172182的博客
05-12 3532
背景（background）： 考虑下图三个图形，要求不重复地走完所有路径。其中，若能回到起点，则这样的环路称为欧拉回路（Euler Circuit），若能不重复走完路径，但终点不一定是起点，则这样的环游称为欧拉环游(Euler tour)。两种问题统称为欧拉路径问题（Euler Path Problem）。 两种欧拉路径问题随然稍有不同，但解法思路一致，以欧拉回路问题介绍Fl...
fleury-algorithm:Fleury算法的Python实现
06-26
Fleury算法是一种用于在图论中找到欧拉路径或欧拉回路的算法，尤其在寻找图的遍历路径时非常有用。欧拉路径是从图的一个顶点出发，沿着边行走并恰好通过每条边一次，最后可能不回到起点。而欧拉回路则是在起点和终点...
弗罗莱（Fleury）算法求欧拉Euler通路回路.doc
05-06
四、欧拉算法的 C 语言描述 void DFS(Graph &G,SqStack &S,int x,int t){ k=0;//一个标志,来标记当前访问的节点是否还有邻接边可供访问 Push(S,x); //将本次遍历边所经由的点入栈 for(i=t;i;i++) if(G[i][x]>0...
欧拉回路/欧拉路径求解，Fleury算法，Hierhoizer算法
qq_43645188的博客
03-01 1222
欧拉路径就是一笔画问题，在一个连通图中，一笔走完所有路径不能有重复路径。 无向图： 具有欧拉回路的 充要条件 图连通，所有点的度数为偶数 具有欧拉路径的 充要条件 图连通，具有0个或者2个奇数度数的结点 有向图： 具有欧拉回路的 充要条件 图连通，所有点的入度等于出度 具有欧拉路径的 充要条件 图连通，一个点的出度大入度1度，一个点的入度大于出度1度，其余点出度等于入度。 Fleury算法跟Hie...
fleury算法的c实现，
04-01
fleury算法的c实现，fleury算法的c++实现，
有向图欧拉路径c语言源程序
10-30
【问题描述】 对N(2≤N≤100000)个由M(2≤M≤1000)个小写字母组成的英文单词排序, 使得相邻的两个单词中前一个单词的末字母等于后一个单词的首字母。 【输入形式】 从标准输入上读入。 输入文件有N(2≤N≤100000)行，每行只含一个单词，单词之间以换行符分隔，以EOF结束。 【输出形式】 输出到标准输出。 输出内容占一行，以换行符结束。对于可以按上述规则排列的输入，输出yes；否则输出no。 【输入样例】 mouse acm malform 【输出样例】 yes 【时间限制】 1s 【空间限制】 65536KB
Fleury（fleury算法）
11-06
Fleury（fleury算法）vs2008
C语言求无向图欧拉回路例子
06-12
自己用C写的无向图找欧拉回路的一个例子。主要用于数据结构的学习
eulerian-path:一种从图中找到欧拉路径的C语言实现
07-03
欧拉路径问题 在图论的数学领域中，欧拉路径是图中的一条轨迹，它只访问每条边一次。 类似地，欧拉回路或欧拉循环是在同一顶点开始和结束的欧拉路径。 莱昂哈德·欧拉 (Leonhard Euler) 在 1736 年解决著名的柯尼斯堡七桥问题时首次讨论了它们。 参考
欧拉回路的求解（dfs和fleury算法）
热门推荐
liwei的专栏
01-29 4万+
欧拉回路的求解 欧拉回路的求解主要有两种方法：DFS 搜索及Fleury（佛罗莱）算法。本节分别介绍这两种方法。 DFS 搜索求解欧拉回路 用DFS 搜索思想求解欧拉回路的思路为：利用欧拉定理判断出一个图存在欧拉通路或回路后，选择一个正确的起始顶点，用DFS 算法遍历所有的边（每条边只遍历一次），遇到走不通就回退。在搜索前进方向上将遍历过的边按顺序记录下来。这组边的排列就组成了一条欧拉通路或
AcWing 102. 最佳牛围栏
Running Snail
09-30 336
题目 农夫约翰的农场由 N 块田地组成，每块地里都有一定数量的牛,其数量不会少于1头，也不会超过2000头。 约翰希望用围栏将一部分连续的田地围起来，并使得围起来的区域内每块地包含的牛的数量的平均值达到最大。 围起区域内至少需要包含 F 块地，其中 F 会在输入中给出。 在给定条件下，计算围起区域内每块地包含的牛的数量的平均值可能的最大值是多少。 输入格式 第一行输入整数 N 和 F ，数据间用空格隔开。 接下来 N 行，每行输入一个整数，第i+1行输入的整数代表第i片区域内包含的牛的数目。 输出格式 输出
hiho一下 第五十周 欧拉路·二 (Fleury算法求欧拉路径)
clogos的专栏
06-14 619
题目1 : 欧拉路·二 时间限制:10000ms 单点时限:1000ms 内存限制:256MB 描述 在上一回中小Hi和小Ho控制着主角收集了分散在各个木桥上的道具，这些道具其实是一块一块骨牌。 主角继续往前走，面前出现了一座石桥，石桥的尽头有一道火焰墙，似乎无法通过。 小Hi注意到在桥头有一张小纸片，于是控制主角捡起了这张纸片，只见上
有向图欧拉回路判断与Fleury算法实现
代码使用了Fleury算法，这是一种经典的用于寻找有向图欧拉路径或回路的算法。该算法的基本思想是从图的一个顶点出发，尝试沿着边进行，但每次选择时会检查当前边的删除是否会导致图中出现桥（即删除后导致图不连通的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值