邻接表的dfs遍历

//输入样例
/*
 5 0
 AB AD AC CD BE DE
 */
//输出
/*
 Please Input the edge x-->y:AB AD AC CD BE DE
 A  1  2  3
 B  0  4
 C  0  3
 D  0  2  4
 E  1  3
 */
//dfs测试数据
/*
 8 0
 Please Input the edge x-->y:AB AC BD BE DH EH HF HG FC GC CA
 A  1  2  2
 B  0  3  4
 C  0  0  5  6
 D  1  7
 E  1  7
 F  2  7
 G  2  7
 H  3  4  5  6
 ABDHEFCG
 */
#include<iostream>
#include<cstdio>
using namespace std;
#define MAXVER 10
int visited[MAXVER];
typedef char Elemtype;
//接下来要连的结点
typedef struct node{
    int num;
    struct node *next;
}slink;
//首结点数组
typedef struct{
    struct{
        Elemtype vertex;
        slink *first;
    }ve[MAXVER];
    int vex,edge,tag;
}adjlist;
//使用简单结构建立图的邻接表
void cregraph(adjlist *G,int n,int m)
{
    G->vex=n;
    G->tag=m;
    int e=0;
    slink *s,*p,*q;
    for(int i=0;i<n;i++){
        G->ve[i].vertex='A'+i;
        G->ve[i].first=NULL;
    }
    Elemtype x,y;
    printf("Please Input the edge x-->y:");
    scanf("%c%c",&x,&y);
    while(x!=' '&&y!=' ')
    {
        e++;
        s=(slink *)malloc(sizeof(slink));
        s->num=y-'A';
        if(G->ve[x-'A'].first==NULL){
            G->ve[x-'A'].first=s;
            s->next=NULL;
        }
        else{
            p=G->ve[x-'A'].first;
            if(p->num>s->num){
                s->next=p;
                G->ve[x-'A'].first=s;
            }
            else{
                q=p->next;
                while(q!=NULL&&q->num<s->num)
                {
                    p=q;
                    q=q->next;
                }
                p->next=s;
                s->next=q;
            }
        }
        if(!G->tag)
        {
            s=(slink *)malloc(sizeof(slink));
            s->num=x-'A';
            if(G->ve[y-'A'].first==NULL) {G->ve[y-'A'].first=s;s->next=NULL;}
            else{
                p=G->ve[y-'A'].first;
                if(p->num>s->num)
                {s->next=p;G->ve[y-'A'].first=s;}
                else{
                    q=p->next;
                    while(q!=NULL&&q->num<s->num) {p=q;q=q->next;}
                    p->next=s;
                    s->next=q;
                }
            }
        }
        getchar();
        scanf("%c%c",&x,&y);
    }
    G->edge=e;
}
//输出用邻接表表示的图的算法
void list(adjlist *G)
{
    slink *p;
    for(int i=0;i<G->vex;i++)
    {
        p=G->ve[i].first;
        printf("%c",G->ve[i].vertex);
        while(p)
        {
            printf("%3d",p->num);
            p=p->next;
        }
        printf("\n");
    }
}

void dfs(adjlist *G,int v)
{
    visited[v]=1;
    printf("%c",G->ve[v].vertex);
    slink *p;
    p=G->ve[v].first;
    while(p)
    {
        if(!visited[p->num])
            dfs(G,p->num);
        p=p->next;
    }
}
void dfsgraph(adjlist *G)
{
    memset(visited,0,sizeof(visited));
    for(int i=0;i<G->vex;i++)
        if(!visited[i]) dfs(G,i);
}
int main()
{
    adjlist *G;
    G=(adjlist *)malloc(sizeof(adjlist));
    int n,m;
    scanf("%d%d",&n,&m);
    getchar();
    cregraph(G,n,m);
    list(G);
    dfsgraph(G);
    printf("\n");
    return 0;
}

时间: 2024-10-18 15:13:17

邻接表的dfs遍历的相关文章

邻接表的深度优先遍历

转载请注明出处http://www.cnblogs.com/hslzju 对<大话数据结构>P241——邻接表的深度优先遍历,进行了自己的理解并完善了代码. 邻接矩阵的深度优先遍历见http://www.cnblogs.com/hslzju/p/5399249.html 举个简单的无序图例子,为了节省时间传手稿. 首先用邻接表的存储结构创建该图,再进行深度优先遍历.代码和解释如下(Qt Creator测试通过): 1 #include <iostream> 2 #include &

邻接表广度深度遍历

#include<iostream> #include<queue> using namespace std; const int MaxVertexNum = 100; bool visited[MaxVertexNum]; int relationNonDir[][2] = {{0,1},{0,2},{1,2},{1,3},{2,6},{2,5},{3,5},{3,4},{4,5}};////无向图 class EdgeNode{ public: int val; int we

PAT1013. Battle Over Cities(邻接矩阵、邻接表分别dfs)

//采用不同的图存储结构结构邻接矩阵.邻接表分别dfs,我想我是寂寞了吧,应该试试并查集,看见可以用并查集的就用dfs,bfs代替......怕了并查集了 //邻接矩阵dfs #include<cstdio>#include<algorithm>using namespace std;const int maxn=1001;int g[maxn][maxn];int n,tmp;bool vis[maxn];void dfs(int v){ vis[v]=true; for(int

数据结构学习笔记05图 (邻接矩阵 邻接表--&gt;BFS DFS)

数据结构之图 图(Graph) 包含 一组顶点:通常用V (Vertex) 表示顶点集合 一组边:通常用E (Edge) 表示边的集合 边是顶点对:(v, w) ∈E ,其中v, w ∈ V 有向边<v, w> 表示从v指向w的边(单行线) 不考虑重边和自回路 无向图:边是无向边(v, w) 有向图:边是有向边<v, w> 连通:如果从V到W存在一条(无向)路径,则称V和W是连通的 连通图(Connected Graph):如果对于图的任一两个顶点v.w∈V,v和w都是连通的,则称

用邻接表实现DFS和BFS

#include <stdio.h> #include <stdlib.h> #define MAXVERTEX 10 typedef char VertexType; //顶点类型 typedef int EdgeType; //边的类型 typedef int ElemType; //队列中元素类型 typedef struct EdgeNode { int adjvex; EdgeType weight; struct EdgeNode *next; }EdgeNode; /

JAVA实现图的邻接表以及DFS

一:定义邻接表结构储存图 package 图的遍历; //邻接表实现图的建立 //储存边 class EdgeNode { int index; // 习惯了用index,其实标准写法是(adjVertex) int value; // 权值 EdgeNode nextArc; // 指向下一条弧 } // 邻接表节点的类型 class VertexNode { String name; EdgeNode firstArc = new EdgeNode(); // 指向第一条弧 } public

邻接表的bfs遍历

//输入样例 /* 5 0 AB AD AC CD BE DE */ //输出 /* Please Input the edge x-->y:AB AD AC CD BE DE A 1 2 3 B 0 4 C 0 3 D 0 2 4 E 1 3 */ //dfs测试数据 /* 8 0 Please Input the edge x-->y:AB AC BD BE DH EH HF HG FC GC CA A 1 2 2 B 0 3 4 C 0 0 5 6 D 1 7 E 1 7 F 2 7 G

浅谈数据结构之图的邻接表深度和广度优先遍历(九)

邻接矩阵是一种不错的图存储结构,但是我们发现,对于边数相对较少的图,这种结构是存在对存储空间的极大浪费的.我们知道,顺序存储结构存在预先分配内存可能造成空间浪费的问题,于是引出了链式存储的结构.同样的,我们也可以考虑对边或弧使用链式存储的方式来避免空间浪费的问题.因此,对于图的存储结构,我们同样引入了一种数组与链表相组合的存储方法,我们一般称之为邻接表. 邻接表的处理方法是这样的:(1).图中顶点用一个一维数组存储,当然,顶点也可以用单链表来存储,不过数组可以较容易的读取顶点的信息,更加方便:另

【数据结构】邻接表的广度与深度遍历

邻接表:数组和链表相结合的方法.图中顶点一般用一个一维数组存储,也可以用单链表存储,每个顶点的邻接点构成一个线性表,一般为单链表. 无向图: 有向图: 代码: #include "stdio.h" #include "stdlib.h" #include "io.h" #include "math.h" #include "time.h" #define OK 1 #define ERROR 0 #defi