图的深度优先和广度优先算法（DFS递归与非递归）

无向图——邻接矩阵的深度优先和广度优先算法实现

测试环境：VS2008（C）

[cpp:showcolumns] view plaincopyprint?

·········10········20········30········40········50········60········70········80········90········100·······110·······120·······130·······140·······150

#include "stdafx.h"
#include <stdlib.h>
#include <malloc.h>
#define INFINITY INT_MAX
#define MAX_VEX 20
#define VRType int
#define VertexType char
#define InfoType int
int *visited;
/********************************/
/**** 图的结构定义 ****/
/********************************/
typedef enum
{
DG,
DN,
UDG,
UDN
}GraphKind;
struct _ArcCell
{
VRType adj; /* note weight */
InfoType *info;
};
typedef struct _ArcCell ArcCell, AdjMatrix[MAX_VEX][MAX_VEX];
struct _MGraph
{
VertexType vexs[MAX_VEX];
AdjMatrix arcs;
int vexnum, arcnum;
GraphKind kind;
};
typedef struct _MGraph MGraph;
/********************************/
/**** 栈的结构定义 ****/
/********************************/
struct _node
{
int ivex;
struct _node *next;
};
typedef struct _node node, *pnode;
struct _stack
{
int size;
pnode ptop;
};
typedef struct _stack stack, *pstack;
/********************************/
/**** 堆的结构定义 ****/
/********************************/
struct _queue
{
pnode front;
pnode rear;
};
typedef struct _queue queue, *pqueue;
/********************************/
/**** 栈的实现 ****/
/********************************/
pstack init_stack(int size)
{
pnode pn=NULL;
pstack ps=NULL;
pn=(pnode)malloc(sizeof(node));
ps=(pstack)malloc(sizeof(stack));
pn->ivex=-1;
pn->next=NULL;
ps->size=size;
ps->ptop=pn;
return ps;
}
int empty_stack(pstack ps)
{
if(ps->ptop->next==NULL)
return 1;
else
return 0;
}
void push_stack(pstack ps, int ivex)
{
pnode pn=NULL;
pn=(pnode)malloc(sizeof(node));
pn->ivex=ivex;
pn->next=ps->ptop;
ps->ptop=pn;
}
int pop_stack(pstack ps)
{
int ivex=-1;
pnode pn=NULL;
if(!empty_stack(ps))
{
pn=ps->ptop;
ps->ptop=ps->ptop->next;
ivex=pn->ivex;
free(pn);
}
return ivex;
}
/********************************/
/**** 堆的实现 ****/
/********************************/
queue init_queue()
{
pnode pn=NULL;
queue qu;
pn=(pnode)malloc(sizeof(node));
pn->next;
pn->ivex=-1;
qu.front=qu.rear=pn;
return qu;
}
int empty_queue(queue qu)
{
if(qu.front==qu.rear)
return 1;
else
return 0;
}
void en_queue(queue qu, int ivex)
{
pnode pn=NULL;
pn=(pnode)malloc(sizeof(node));
pn->ivex=ivex;
pn->next=qu.rear->next;
qu.rear=pn;
}
int de_queue(queue qu)
{
int ivex=-1;
pnode pn=NULL;
if(!empty_queue(qu))
{
pn=qu.front;
qu.front=qu.front->next;
ivex=pn->ivex;
free(pn);
}
return ivex;
}
/********************************/
/**** 图的实现 ****/
/********************************/
int LocateVex(MGraph g, char ch)
{
int i;
for(i=1; i<=g.vexnum; i++)
if(ch==g.vexs[i])
return i;
return -1;
}
MGraph Create_UDG()
{
int i, j, w, p1, p2;
char ch1, ch2;
MGraph g;
printf("Enter vexnum arcnum: ");
scanf("%d %d", &g.vexnum, &g.arcnum);
getchar();
for(i=1; i<=g.vexnum; i++)
for(j=1; j<=g.vexnum; j++)
g.arcs[i][j].adj=g.arcs[j][i].adj=INFINITY; /* UDG should define i-j and j-i */
printf("Enter %d vex.../n", g.vexnum);
for(i=1; i<=g.vexnum; i++)
{
printf("vex %d: ", i);
scanf("%c", &g.vexs[i]);
getchar();
}
printf("Enter %d arc.../n", g.arcnum);
for(i=1; i<=g.arcnum; i++)
{
printf("arc %d: ", i);
scanf("%c %c %d", &ch1, &ch2, &w);
getchar();
p1=LocateVex(g, ch1);
p2=LocateVex(g, ch2);
g.arcs[p1][p2].adj=g.arcs[p2][p1].adj=w;
}
return g;
}
int FirstVex(MGraph g, int i)
{
int k;
if(i>=1 && i<=g.vexnum)
for(k=1; k<=g.vexnum; k++)
if(g.arcs[i][k].adj!=INFINITY)
return k;
return -1;
}
int NextVex(MGraph g, int i, int j)
{
int k;
if(i>=1 && i<=g.vexnum && j>=1 && j<=g.vexnum)
for(k=j+1; k<=g.vexnum; k++)
if(g.arcs[i][k].adj!=INFINITY)
return k;
return -1;
}
void DFS(MGraph g, int i)
{
int j;
if(!visited[i])
{
visited[i]=1;
printf("%3c", g.vexs[i]);
for(j=FirstVex(g, i); j>=1; j=NextVex(g, i, j))
if(!visited[j])
DFS(g, j);
}
}
void DFS_Graph(MGraph g)
{
int i;
visited=(int *)malloc((g.vexnum+1)*sizeof(int));
for(i=1; i<=g.vexnum; i++)
visited[i]=0;
for(i=1; i<=g.vexnum; i++)
if(!visited[i])
DFS(g, i);
}
void DFS2_Graph(MGraph g)
{
int i, j, k;
pstack ps=NULL;
ps=init_stack(g.vexnum);
visited=(int *)malloc((g.vexnum+1)*sizeof(int));
for(i=1; i<=g.vexnum; i++)
visited[i]=0;
for(i=1; i<=g.vexnum; i++)
if(!visited[i])
{
visited[i]=1;
printf("%3c", g.vexs[i]);
push_stack(ps, i);
k=i;
while (!empty_stack(ps))
{
for(j=FirstVex(g, k); j>=1; j=NextVex(g, k, j))
{
if(!visited[j])
{
visited[j]=1;
printf("%3c", g.vexs[j]);
push_stack(ps, j); /* push all visited ivex */
k=j; /* newer node */
}
}
k=pop_stack(ps);
}
}
}
void BFS_Graph(MGraph g)
{
int i, j, k;
queue qu;
qu=init_queue();
visited=(int *)malloc((g.vexnum+1)*sizeof(int));
for(i=1; i<=g.vexnum; i++)
visited[i]=0;
for(i=1; i<=g.vexnum; i++)
if(!visited[i])
{
visited[i]=1;
printf("%3c", g.vexs[i]);
en_queue(qu, i);
while (!empty_queue(qu))
{
k=de_queue(qu);
for(j=FirstVex(g, k); j>=1; j=NextVex(g, k, j))
if(!visited[j])
{
visited[j]=1;
printf("%3c", g.vexs[j]);
en_queue(qu, j);
}
}
}
}
/********************************/
/**** 主函数 ****/
/********************************/
int _tmain(int argc, _TCHAR* argv[])
{
MGraph g;
g=Create_UDG();
printf("/nDFS: ");
DFS_Graph(g); /* recursion */
printf("/nDFS: ");
DFS2_Graph(g); /* non recursion */
printf("/nBFS: ");
BFS_Graph(g);
printf("/n");
return 0;
}

运行结果：

原文链接：http://blog.csdn.net/sunboy_2050/article/details/5684519

转载于:https://www.cnblogs.com/10jschen/archive/2012/08/15/2639636.html

图的深度优先和广度优先算法（DFS递归与非递归）相关推荐

树与二叉树的深度优先与广度优先算法（递归与非递归）
本博客前面文章已对树与二叉树有过简单的介绍,本文主要是重点介绍有关二叉树的一些具体操作与应用阅读本文前,可以先参考本博客各种基本算法实现小结(三)-- 树与二叉树和各种基本算法实现小结( ...
数据结构 - 图（图的深度优先和广度优先）
图的基本介绍为什么要有图这种数据结构数据结构有线性表和树线性表局限与一个直接前驱和一个直接后继的关系树也只能右一个直接前驱也就是父节点当我们需要表示多对多的关系时,这里我们就需要用到图这种数 ...
Python 实现图的深度优先和广度优先搜索
在介绍 python 实现图的深度优先和广度优先搜索前,我们先来了解下什么是"图". 1 一些定义顶点顶点(也称为"节点")是图的基本部分.它可以有一个名称 ...
python爬虫算法深度优先_爬虫课程（四）｜深度优先和广度优先算法
深度优先和广度优先算法在爬取一个整站上经常用到,本课程主要讲解这两个算法的原理以及使用过程. 一.网站的树结构 1.1.一个网站的url结构图以知乎为例,知乎目前有发现.话题.Live.书店.圆桌. ...
深度优先和广度优先算法（例题）
在LeetCode上面刷题刷到一道二叉树的题,这道题我认为对学习树的深度优先和广度优先算法有一定的帮助,先来看一下题这道题是这样的: 给定一棵二叉树,想象自己站在它的右侧,按照从顶部到底部的顺序,返 ...
P202 例9-2 以如图9-8所示的带权有向图为例，编写测试上述图的深度优先和广度优先遍历函数的程序。
P202 例9-2 以如图9-8所示的带权有向图为例,编写测试上述图的深度优先和广度优先遍历函数的程序. 头文件1:SeqList.h #include<stdio.h>#define M ...
python创建树结构、求深度_数据结构-树以及深度、广度优先遍历（递归和非递归，python实现）...
前面我们介绍了队列.堆栈.链表,你亲自动手实践了吗?今天我们来到了树的部分,树在数据结构中是非常重要的一部分,树的应用有很多很多,树的种类也有很多很多,今天我们就先来创建一个普通的树.其他各种各样的树 ...
傅里叶变换算法c语言实现（递归与非递归）
1.算法设计原理分析把傅里叶变换公式进行拆分,按奇偶进行分组,使之转外为两个T(n/2)的计算式. 这样就可以找到了递归特性,可以一直拆分下去,直到一组只有一个数值.递归算法实现则可以为在每次递归中 ...
九十五、二叉树的递归和非递归的遍历算法模板
@Author:Runsen 刷Leetcode,需要知道一定的算法模板,本次先总结下二叉树的递归和非递归的遍历算法模板. 二叉树的四种遍历方式,前中后加上层序遍历.对于二叉树的前中后层序遍历,每种遍 ...

图的深度优先和广度优先算法（DFS递归与非递归）

图的深度优先和广度优先算法（DFS递归与非递归）相关推荐

最新文章

热门文章