图的深度优先搜索 递归和非递归实现 c++版本

最新推荐文章于 2024-05-20 15:46:15 发布
最新推荐文章于 2024-05-20 15:46:15 发布
阅读量3.9k 收藏 6
点赞数 2
分类专栏： 数据结构 文章标签： 算法 数据结构 图 深度优先搜索 广度优先搜索
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/suifeng50/article/details/32139385
版权

本文参考了李春葆版本的数据结构上机指导，但是原版是c代码，

本文用了c++实现，并且修复了深度优先搜索非递归的一个bug。

graph.cpp文件：

#include  "graph.h"
#include  <queue>
#include  <stack>
int  visited[ MAXV  ];
MGraph  ::MGraph( int  A [100][10],  int   nn  ,  int   ee )
{
                e=  ee  ;
                n=  nn  ;
                  for  ( int  i=0;i<n;i++)
                {
                                  for  ( int  j=0;j<n;j++)
                                                edges[i][j]=  A  [i][j];
                }
}

void   MGraph  ::DispMat(  MGraph   g  )
{
                  int  i,j;
                  for  (i=0;i< g  .n;i++)
                {
                                  for  (j=0;j< g  .n;j++)
                                                cout<<  g  .edges[i][j]<< "       "  ;
                                cout<<endl;
                }

}


ALGragh  ::ALGragh( int  a [  MAXV ][10],  int   n  ,  int   e )
{
                  ALGragh  ::n= n  ;
                  ALGragh  ::e= e  ;
                  for  ( int  i=0;i<  n ;i++)
                {
                                adjlist[i].firstarc=  NULL  ;
                }
                  for  ( int  i=0;i<  n ;i++)
                                  for  ( int  j=  n -1;j>=0;j--)
                                {
                                                  if  ( a  [i][j]!=0)
                                                {      //作用域里面，必须动态分配。直接写ArcNode p(adjlist[i].firstarc,j,a[i][j])会被析构
                                                                  ArcNode  *p= new  ArcNode  (adjlist[i].firstarc,j,  a  [i][j]);
                                                                adjlist[i].firstarc=p;
                                                }
                                }
}

void   ALGragh  ::DispAdj(  ALGragh  *  G  )
{
                  ArcNode  *p;
                  for  ( int  i=0;i<  G ->n;i++)
                {
                                p=  G  ->adjlist[i].firstarc;  //p指向第一条边
                                  if  (p!= NULL  )
                                                cout <<i<< ":  "  ;
                                  while  (p!= NULL  )
                                {
                                                cout<<(p->adjvex)<<  "  "  ; //输出终点
                                                p=p->nextarc;      //指向下一条边
                                }
                                cout<<endl;
                }
}


void   ALGragh  ::DFS(  int   v ,  int   flag )  //深度优先搜索 递归
{
                  if  ( flag  )
                {
                                memset(visited,0,  sizeof  (visited));
                                  flag  =0;
                }

                  if  ( v  >=n ||  v <0)
                {
                                cout<<  "error point!"  ;
                                  return  ;
                }
                visited[  v  ]=1;
                cout<<  v  << "  "  ;
                  ArcNode  *p=adjlist[ v  ].firstarc;
                  while  (p!= NULL  )
                {
                                  if  (!visited[p->adjvex])
                                                DFS(p->adjvex,  flag  );
                                p=p->nextarc;
                }
}

void   ALGragh  ::DFS1(  int   v )  //深度优先搜索 非递归
{
                memset(visited,0,  sizeof  (visited));
                  if  ( v  >=n ||  v <0)
                {
                                cout<<  "error point!"  ;
                                  return  ;
                }
                  stack  < ArcNode  *> s;
                visited[  v  ]=1;
                cout<<  v  << "  "  ;
                  ArcNode  *q;
                s.push(adjlist[  v  ].firstarc);
                  while  (!s.empty())
                {
                                q=s.top();  //s.pop();
                                  while  (q!= NULL  )
                                {
                                                  if  (!visited[q->adjvex])
                                                {
                                                                visited[q->adjvex]=1;
                                                                cout<<q->adjvex<<  "  "  ;      
                                                                s.push(adjlist[q->adjvex].firstarc);  //定点进栈
                                                                  break  ;
                                                }
                                                  else
                                                {
                                                                q=q->nextarc;         //与当前结点相连的边都访问了（即往该结点走不下去了）     该节点出栈
                                                                  if  (q== NULL  )
                                                                                s.pop();
                                                }
                                }
                }
}


void   ALGragh  ::BFS(  int   v )  //广度优先搜索
{
                memset(visited,0,  sizeof  (visited));
                  if  ( v  >=n ||  v <0)
                {
                                cout<<  "error point!"  ;
                                  return  ;
                }
                  queue  < int  > q;
                  ArcNode  *p;
                q.push(  v  );
                visited[  v  ]=1;
                cout<<  v  << "  "  ;
                  while  (!q.empty())
                {
                                  v  =q.front(); q.pop();
                                p=adjlist[  v  ].firstarc;
                                  while  (p!= NULL  )
                                {
                                                  if  (!visited[p->adjvex])
                                                {
                                                                visited[p->adjvex]=1;
                                                                cout<<p->adjvex<<  "  "  ;
                                                                q.push(p->adjvex);
                                                }
                                                p=p->nextarc;
                                }              
                }
}

main.cpp文件：

#include  "graph.h"
int  main()
{
                  -------图的遍历算法----//
                  /*int A[100][6]={
                                {0,5,0,7,0,0},
                                {0,0,4,0,0,0},
                                {8,0,0,0,0,9},
                                {0,0,5,0,0,6},
                                {0,0,0,5,0,0},
                                {3,0,0,0,1,0}
                };*/
                  int  A[100][10]={
                                0,1,1,1,0,0,0,0,0,0,
                                1,0,0,1,0,1,1,1,1,0,
                                0,1,0,1,1,1,0,0,0,0,
                                0,0,0,0,0,1,0,0,0,0,
                                0,1,1,1,0,1,0,0,0,0,
                                0,1,0,0,0,0,0,0,0,0,
                                0,1,1,1,0,0,0,1,1,0,
                                0,0,1,1,1,1,1,0,1,0,
                                0,0,1,1,0,0,0,0,0,0,
                                0,0,1,0,0,0,0,0,1,0
                };
                MGraph g(A,10,10);                                                               //图的邻接矩阵类型
                ALGragh G(A,10,10);                                                             //图的临界表类型
                g.DispMat(g);
                G.DispAdj(&G);
                G.DFS(0,1); cout<<endl;
                G.DFS1(0); cout<<endl;

graph.h文件：

#include  "C++global.h" //图的数据结构
typedef   int  InfoType ;
#define   MAXV  100    //最大顶点个数

//------------------------------------//
//-----------用邻接矩阵存储-------------//
class   VertexType       //顶点类型
{
private  :
                  int  no;       //顶点编号
                  InfoType  info;  //顶点的其他信息；
};
class   MGraph       //图的定义
{
public  :    
                  void  DispMat( MGraph  g);
                MGraph(){n=0;e=0;memset(edges,0,  sizeof  (edges));}
                MGraph(  int  A[100][10], int  n,  int  e);
private  :
                  int  edges[ MAXV  ][  MAXV ];  //邻接矩阵
                  int  n,e;                //顶点数，弧数
                  VertexType  vexs[ MAXV  ];  //图的邻接矩阵类型。
};


//------------------------------------//
//------------------------------------//
//------------用临界表存储-------------//
class   VNode  ;
class   ArcNode               //弧结点结构类
{
                  friend   class     ALGragh ;
                  //friend class VNode;
public  :
                ArcNode(){}
                ArcNode(  ArcNode  * next  ,  int   adj ,  int   i )
                {              adjvex=  adj  ;            nextarc=  next ;        info=  i  ;    }
                
private  :
                  int  adjvex;         
                  ArcNode  *nextarc;     //指向下一条弧的指针
                  InfoType  info;        //弧先关信息，这里存放权值
};

class   VNode  {                //头结点类
                  //friend class ArcNode;
                  friend   class     ALGragh ;
private  :
                  int  data;               //顶点信息
                  ArcNode  *firstarc;      //指向第一条弧
};

typedef   VNode  AdjList [  MAXV  ];  //AdjList是临界表类型

class     ALGragh  {      //图的临界表类型
public  :
                ALGragh();
                ALGragh(  int  a[ MAXV  ][10],  int  n,  int  e );
                  void  DispAdj( ALGragh  *G);
                  void  DFS( int  v,  int  flag);
                  void  DFS1( int  v);  //深度优先 非递归
                  void  BFS( int  v);
private  :
                  AdjList  adjlist;      //邻接表
                  int  n,e;
};


输出：


天涯追梦_
关注
  • 2
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
图的深度优先搜索遍历(邻接表&邻接矩阵，递归&非递归)(C++)
zhujiahui622的专栏
08-09 5286
图的深度优先搜索遍历可有递归和迭代两种方法。递归的方式比较容易，每次以当前节点的未被访问的邻接节点为新的出发点去遍历即可，编程的时候注意维护好全局的访问标记以及访问序列即可(可以以引用的方式传递)。非递归(迭代)的方式需要借助栈。从起点开始，先保存栈顶，然后栈顶出栈，并将该节点(初始的时候为起点)的所有未被访问的邻接节点依次入栈；重复直到栈为空。C++代码如下： 这里有4个函数，分别是： 邻接表
图的深度优先遍历非递归实现—C++
weixin_43011522的博客
09-07 5112
思路： 利用栈非递归实现深度优先遍历（DFS）图。先把起始顶点访问并入栈；然后每次取栈顶元素，找到一个与栈顶顶点连接并且未被访问的顶点，随即访问此顶点，并将此顶点入栈；直到某一顶点没有出边（针对有向图）或者所有连接的顶点都已经被访问过了，删除栈顶元素；循环上述步骤，直到栈为空，深度优先遍历结束。 注：深度优先遍历到所有顶点的前提是此图为连通图；若此图为两个连通图组成的图...
C++的数据结构(十三）：图的深度优先遍历（DFS）
最新发布
全栈工程师Linda的博客
05-20 703
C++的数据结构(十三）：图的深度优先遍历（DFS）
C++ 算法篇 深度优先搜索（DFS）
流年的博客
01-28 1万+
图的遍历 图的遍历为从图中某一顶点出发访遍图中其余顶点，且使每一个顶点仅被访问一次的过程。 对于图的遍历，不想树那么简单，需要在遍历的过程中把访问过的顶点打上标记，以避免访问多次。具体办法是设置一个访问数组visited[n]，n是图中顶点的个数，初始值为0，访问后设置为1。 对于图的遍历来说，通常有两种遍历方案：深度优先遍历和广度优先遍历。 深度优先遍历 深度优先遍历（Depth_Fi...
无向图的深度优先遍历非递归_数据结构-图（图的基本实现C++）
weixin_39757743的博客
11-21 709
​一、图的概念图是一种比较复杂的非线性数据结构图(Graph)是由顶点的有穷非空集合和顶点之间边的集合组成，通常表示为：G(V,E)，其中，G表示一个图，V是图G中顶点的集合，E是图G中边的集合。图区分有向图和无向图1、无向图(Undirected graphs)如果图中任意两个顶点之间的边都是无向边，则称该图为无向图。无向图相关概念：顶点、边图1-无向图2、有向图(Directed graphs...
acwing-843.n-皇后问题
weixin_43211195的博客
05-02 1352
题目描述 n−皇后问题是指将 n 个皇后放在 n×n 的国际象棋棋盘上，使得皇后不能相互攻击到，即任意两个皇后都不能处于同一行、同一列或同一斜线上。 现在给定整数 n，请你输出所有的满足条件的棋子摆法。 输入格式 共一行，包含整数 n。 输出格式 每个解决方案占 n 行，每行输出一个长度为 n 的字符串，用来表示完整的棋盘状态。 其中 . 表示某一个位置的方格状态为空，Q 表示某一个位置的方格上摆着皇后。 每个方案输出完成后，输出一个空行。 注意：行末不能有多余空格。 输出方案的顺序任意，只要不重复且没有
二叉树遍历的c++实现（递归和非递归深度优先遍历）
09-13
深度优先遍历的实现； 广度优先遍历的实现；
Graph1_非递归算法进行深度优先遍历和广度优先遍历_
10-02
本话题主要探讨如何使用非递归算法对无向图进行深度优先遍历（DFS, Depth First Search）和广度优先遍历（BFS, Breadth First Search），这两种遍历方法在图算法中有着广泛的应用。 **1. 邻接表表示法** 在处理大...
C++非递归队列实现二叉树的广度优先遍历
09-03
以下是一个C++非递归队列实现二叉树广度优先遍历的详细步骤： 1. 初始化一个队列`queue*> q`，并将根节点`root`入队。 2. 创建一个循环，只要队列不为空，就继续遍历。 3. 在循环内，首先取出队首元素`p = q....
深度优先搜索（DFS）非递归
04-06
深度优先搜索（DFS，Depth-First Search）是一种用于遍历或搜索树或图的算法，其基本思想是尽可能深地探索树的分支。在二叉搜索树（Binary Search Tree, BST）中，DFS通常用于顺序地访问节点，因为它可以按照特定...
C++实现二叉树非递归遍历方法实例总结
09-04
在C++中，这三种遍历可以通过递归和非递归两种方法实现。本篇文章将重点讨论非递归遍历方法。 非递归遍历通常依赖于栈（stack）数据结构来模拟递归调用的过程，避免了函数调用的开销，并且可以避免深度过大的栈溢出...
深度优先搜索c++/c代码实现
海波波的博客
05-25 2737
原理博主就不讲了，毕竟其他人写的很好了，这里写一个实现样例。 无向图+邻接链表+深度优先搜索 如下 #include <iostream> #include <bits/stdc++.h> //这个头文件要注意一下，包含着c++的所有头文件,要注意的是，有些oj是不允许使用这个的。 using namespace std; #define MAX 105 typed...
深度优先搜索非递归实现
Tracy Mcgrady的专栏
10-16 7758
源代码如下： /* dfs.c */ #include #include "stack.h" #define N 6 struct adj_matrix { int vertex[N]; int edge[N][N]; }; struct adj_matrix matrix = { {1, 2, 3, 4, 5, 6}, {{0, 1, 0, 1, 0, 0}, {0
图的深度优先遍历（递归、非递归；邻接表，邻接矩阵）
热门推荐
zjq_smile的博客
07-23 2万+
众所周知，图有经典的两种遍历方式：深度优先遍历和广度优先遍历 首先我们就来说说深度优先遍历，其他的不说了，直接上代码，分为递归个非递归的方式啊首先是递归的方式实现的，比较简单，考虑到存储结构由邻接矩阵和邻接表，有分为两种：一种是邻接矩阵存储的递归，简单点说就是用数组来存储；另一种是邻接表存储的，也就是说用链表的方式存储的一、递归 1、邻接矩阵：#include<stdio.h> #define
图的深度优先搜索（DFS）简介与实现（递归与非递归方法）
weixin_30702887的博客
05-07 1183
上一篇刚刚学习了C++图的实现，今天对深度优先搜索（DFS）进行了一定学习，并作出一定实现。在本文中图的实现，以及相应的函数调用（如获得第一个邻接顶点、获得下一个邻接顶点等）均是基于上文中的实现，故如果想参考测试代码，还需导入上文中相应的类定义。关于C++图的实现可参考此处，这里实现了对图的邻接表以及邻接矩阵两种实现，而本文的深度优先搜索对于上面两种实现均是可行的。 ...
图的遍历之深度优先搜索算法&&广度优先优先算法的实现
哒哒的博客
02-28 8752
一.序 和树的遍历类似，我们希望从图中的某一个顶点出发访问图中其余顶点，保证每个顶点只被访问一次，这一过程叫做图的遍历。图的遍历算法是求解图的连通性问题（最小生成树），拓扑排序，求关键路径的基础。 而为了保证同一个顶点不被访问多次，在遍历图的的过程中，必须记下访问过的顶点。为此，需要设立一个辅助数组visited[0..n-1],初始值设置为0或假，这样其不为0或者为真时，表示此顶点已经被访问过
深度优先搜索（C++代码实现）
weixin_43624549的博客
08-29 2158
深度优先搜索（C++代码实现） 举个例子，比如现在你的位置为（1,1），你需要移动到一个位置（n，m）， 并且路途中有多个障碍物阻挡你的前进，求出最少需要移动的次数。 对于这个问题，我们可以使用从起点开始顺时针进行移动（即：先向右，再向下，再 向左，再向上）。并且使用二维数组模拟一下地图。当碰到障碍物的时候进行优先的 顺时针的方向（右->下->左->上）总有一条路能走通，就接着继续走，直到目的地， 这是其中的一条可行的路，然后就模拟所有的路，找到最短的那条即可。 OK，分析完毕，开始写代
【数据结构】邻接矩阵表示法的图的深度广度优先遍历递归和非递归遍历
luoyesiqiu的专栏
02-02 1万+
假设有以下结构的图： 用邻接矩阵表示如下： 因为他是无向图，我们可以发现他的矩阵是对角对称的。矩阵中每一行每一列都可以看成是一个顶点，矩阵中的元素表示着该顶点与其他顶点的关系，当元素的值为1说明它与对应列的顶点有边相连，如果他们的值为0，表示他们没有边相连。下面我们来看看我们怎么遍历这个图。 1.深度优先遍历：假设我们从A这个顶点开始遍历，当访问到A点的时候它会找与A相连的第一个
图的深度优先搜索非递归c++
10-29
图的深度优先搜索非递归实现可以使用栈来实现。具体步骤如下： 1. 创建一个栈，将起始顶点入栈，并标记为已访问。 2. 当栈不为空时，取出栈顶元素，访问该顶点，并将其未被访问的邻接点入栈，并标记为已访问。 3. ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值