深度优先遍历与广度优先遍历

原创 2012年03月29日 09:09:09
代码一修改就乱了,CSDN这方面还有等提高啊~~~~~~~
//zhangjun03402@163.com
#include <iostream>
#include <cstdlib>

#define MAX_NUM 4

using std::cout;
using std::cin;
using std::endl;

typedef struct ArcNode{
    int adjvex;
    struct ArcNode *next;
}ArcNode;

typedef struct VexNode{
    int data;
    ArcNode * FirstArc;
}VexNode;

int visited[MAX_NUM];

typedef struct QNode{
    int data;
    struct QNode *next;
}QNode, *QueuePtr;

typedef struct{
    QueuePtr front;
    QueuePtr rear;
}LinkQueue;

void InitQueue(LinkQueue *&q){
    q = (LinkQueue *)malloc(sizeof(LinkQueue));
    q->front=q->rear=(QueuePtr)malloc(sizeof(struct QNode));
    if(!q->front)
        exit(0);
    q->front->next=NULL;
}

bool empty(LinkQueue *&q){
    return q->front==q->rear;
}

void enqueue(LinkQueue *&q, int e){
    QueuePtr node = (QueuePtr)malloc(sizeof(QNode));
    if( !node )
        exit(0);
    node->data = e;
    node->next=NULL;
    q->rear->next=node;
    q->rear = node;
}

void dequeue(LinkQueue *&q, int &e){
    QueuePtr node;
    if(empty(q))
        return;
    node = q->front->next;
    e = node->data;
    q->front->next=node->next;
    if( !node->next )   //这个地方要注意,队列空时,尾指针要指向“头结点” 
        q->rear = q->front;
    free(node);
}

void CreatGraph(VexNode G[], int n)
{
    int i, e;
    ArcNode *p, *q = NULL;
    cout<<"Input "<<MAX_NUM<<" vertexs' value:"<<endl;
    for(i=0; i<n; i++){
        cin>>G[i].data; //用scanf("%d",G[i])居然也可以
        G[i].FirstArc = NULL;
    }
    for(i=0; i<n; i++){
        cout<<"Creat the edges for the NO."<<i<<" vertex, input its adjvex..."<<endl;
        cin>>e;
        while(e != 1111){ //为什么以-1为结束判断标志不行... 
            p=(ArcNode *)malloc(sizeof(struct ArcNode));
            p->next = NULL;
            p->adjvex = e;
            if(G[i].FirstArc == NULL)
                G[i].FirstArc = p;
            else 
                q->next = p;
            q = p;
            cin>>e;
        }
    }
}

int FirstAdj(VexNode G[],int v){
    if(G[v].FirstArc != NULL)
        return (G[v].FirstArc)->adjvex;
    return -1;
}

int NextAdj(VexNode G[], int v){
    ArcNode *p;
    p = G[v].FirstArc;
    while( p!= NULL ){
        if( !visited[p->adjvex] )
            return p->adjvex;
        else
            p = p->next;
    }
    return -1;
}

void DFS(VexNode G[], int v){
    int w;
    
    visited[v]=1;
    cout<<G[v].data<<"->";

    for(w=FirstAdj(G, v); w != -1; w=NextAdj(G, v))
    {
        if( visited[w]==0 )
            DFS(G, w);
    }
}

void Travel_DFS(VexNode G[], int n)
{
    for(int i=0;i<n;i++){
        visited[i] = 0;
    }
    for(int i=0; i<n; i++)
        if(visited[i] == 0)
            DFS(G,i);
}

void BFS(VexNode G[], int v)
{
    LinkQueue *q ; //(LinkQueue *)malloc(sizeof(LinkQueue));
    int flag, w;
    
    InitQueue(q);
    cout<<G[v].data<<"->";
    visited[v]=1;
    enqueue(q, v);
    
    while(!empty(q)){
        dequeue(q, v);
        w = FirstAdj(G, v);
        while(w != -1){
            if(visited[w]==0){
                cout<<G[w].data<<"->";
                enqueue(q,w);
                visited[w]=1;
            }
            w = NextAdj(G, v);
        }
    }
}

void Travel_BFS(VexNode G[], int n)
{
    for(int i=0;i<n;i++){
        visited[i] = 0;
    }
    for(int i=0; i<n; i++)
        if(visited[i] == 0)
            BFS(G,i);
}

int main(){
    VexNode G[MAX_NUM];
    CreatGraph(G, MAX_NUM);
    cout<<"DFS:"<<endl;
    //DFS(G, 0);
    Travel_DFS(G,MAX_NUM);  //深度优先遍历 
    cout<<"NULL"<<endl;
    
    cout<<"BFS:"<<endl;
    //BFS(G, 0);  //此时调用,之前深度遍历时已将visited[]全变为1 
    Travel_BFS(G,MAX_NUM);  //广度优先遍历 
    
    cout<<"NULL"<<endl;
    
    system("PAUSE");
    return 0;
}
采用邻接链表表示法,n个顶点,e条边,二种遍历方式时间复杂度相同,首先是尝试从每个顶点遍历一遍,为O(n),然后查找邻接边相连的顶点,为O(e),总时间复杂度为O(n+e)。若采用邻接矩阵表示法,则时间复杂度为O(N^2)。

版权声明:本文为博主原创文章,未经博主允许不得转载。

图的深度优先遍历和广度优先遍历

1.深度优先遍历(DFS) (1)从某个顶点V出发,访问顶点并标记为已访问 (2)访问V的邻接点,如果没有访问过,访问该顶点并标记为已访问,然后再访问该顶点的邻接点,递归执行      如果该顶点已访...
  • lom9357bye
  • lom9357bye
  • 2015年06月23日 13:01
  • 13182

图的广度优先遍历

本文要解决的问题: 总结一下图的广度优先遍历 简述 广度优先遍历算法是图的另一种基本遍历算法,其基本思想是尽最大程度辐射能够覆盖的节点,并对其进行访问。以迷宫为例,深度优先搜索更像是...
  • sbq63683210
  • sbq63683210
  • 2016年06月19日 22:07
  • 824

算法:图的广度优先遍历(Breadth First Search)

图的遍历和树的遍历类似,我们希望从图中某一顶点出发访遍图中其余顶点,且使每一个顶点仅被访问一次,这一过程就叫做图的遍历(Traverse Graph)。 图的遍历方法一般有两种,第一种是我们在前面讲...
  • Simba888888
  • Simba888888
  • 2013年04月30日 09:22
  • 16988

数据结构:图的遍历--深度优先、广度优先

图的遍历是指从图中的某一顶点出发,按照一定的策略访问图中的每一个顶点。当然,每个顶点有且只能被访问一次。 在图的遍历中,深度优先和广度优先是最常使用的两种遍历方式。这两种遍历方式对无向图和有向图都是适...
  • zhangxiangDavaid
  • zhangxiangDavaid
  • 2014年08月02日 11:20
  • 35460

【数据结构】图的遍历方法 深度优先遍历和广度优先遍历

图的遍历方法 深度优先遍历和广度优先遍历 接着上次的文章“图的构建(邻接链表法)”,邻接链表法构建图相对来说比较简单,并且遍历起来也相对简单,但是要是动态添加图的节点和图的边,则是实在不方便,不过现在...
  • sundong_d
  • sundong_d
  • 2015年04月11日 09:45
  • 14596

算法学习 - 图的广度优先遍历(BFS) (C++)

广度优先遍历广度优先遍历是非常常见和普遍的一种图的遍历方法了,除了BFS还有DFS也就是深度优先遍历方法,我在我下一篇博客里面会写。遍历过程相信每个看这篇博客的人,都能看懂邻接链表存储图。 不懂的人...
  • chenfs1992
  • chenfs1992
  • 2015年04月01日 02:25
  • 4171

深度优先遍历与广度优先遍历 递归与非递归思路

深度优先遍历与广度优先遍历 递归与非递归思路 深度优先遍历  http://www.cnblogs.com/debuging/archive/2013/07/24/3210027.html 1.深...
  • mmbbz
  • mmbbz
  • 2017年02月13日 11:11
  • 1122

树的广度优先遍历与深度优先遍历算法

1 树的广度优先搜索算法 广度优先搜索算法(Breadth First Search),又叫宽度优先搜索,或横向优先搜索。 是从根节点开始,沿着树的宽度遍历树的节点。如果所有节点均被访问,...
  • lmingyin5
  • lmingyin5
  • 2015年08月04日 21:22
  • 9709

广度优先遍历_改造为递归方式

import java.util.ArrayList; import java.util.HashSet; import java.util.List; import java.util.Set; ...
  • u011925500
  • u011925500
  • 2014年03月01日 16:05
  • 2199

java 二叉树 建立完全二叉树和广度优先遍历

今天想写个如何建立完全二叉树的方法。顺便把二叉树的广度优先遍历也写了下。其实这两者思路都相似,都是用队列实现的,先进先出。若有任何问题,敬请指出来! 一.建立完全二叉树思路: 先从根节点开始,判断左右...
  • fengyun703
  • fengyun703
  • 2015年12月05日 14:16
  • 1212
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:深度优先遍历与广度优先遍历
举报原因:
原因补充:

(最多只允许输入30个字)