第十一周【项目3-图遍历算法实现】

blgbb

于 2017-11-09 11:10:26 发布

阅读量182

点赞数

分类专栏：第十一周

本文链接：https://blog.csdn.net/z249486888/article/details/78487389

版权

第十一周专栏收录该内容

3 篇文章 0 订阅

订阅专栏

*All rights reservrd.

*作者：赵楷文

*完成时间：2017年11月09日

*版本号：v1.0

*问题描述:　实现图遍历算法，分别输出如下图结构的深度优先(DFS)遍历序列和广度优先遍历(BFS)序列。
这里写图片描述

一、graph.h

#include <stdio.h>
#include <malloc.h>

#define MaxSize 100
typedef char ElemType;
typedef struct node
{
    ElemType data;
    int ltag,rtag;      //Ôö¼ÓµÄÏßË÷±ê¼Ç
    struct node *lchild;
    struct node *rchild;
} TBTNode;

void CreateTBTNode(TBTNode * &b,char *str)
{
    TBTNode *St[MaxSize],*p=NULL;
    int top=-1,k,j=0;
    char ch;
    b=NULL;             //½¨Á¢µÄ¶þ²æÊ÷³õÊ¼Ê±Îª¿Õ
    ch=str[j];
    while (ch!='\0')    //strÎ´É¨ÃèÍêÊ±Ñ»·
    {
        switch(ch)
        {
        case '(':
            top++;
            St[top]=p;
            k=1;
            break;      //Îª×ó½áµã
        case ')':
            top--;
            break;
        case ',':
            k=2;
            break;                          //ÎªÓÒ½áµã
        default:
            p=(TBTNode *)malloc(sizeof(TBTNode));
            p->data=ch;
            p->lchild=p->rchild=NULL;
            if (b==NULL)                    //*pÎª¶þ²æÊ÷µÄ¸ù½áµã
                b=p;
            else                            //ÒÑ½¨Á¢¶þ²æÊ÷¸ù½áµã
            {
                switch(k)
                {
                case 1:
                    St[top]->lchild=p;
                    break;
                case 2:
                    St[top]->rchild=p;
                    break;
                }
            }
        }
        j++;
        ch=str[j];
    }
}

void DispTBTNode(TBTNode *b)
{
    if (b!=NULL)
    {
        printf("%c",b->data);
        if (b->lchild!=NULL || b->rchild!=NULL)
        {
            printf("(");
            DispTBTNode(b->lchild);
            if (b->rchild!=NULL) printf(",");
            DispTBTNode(b->rchild);
            printf(")");
        }
    }
}

TBTNode *pre;                       //È«¾Ö±äÁ¿

void Thread(TBTNode *&p)
{
    if (p!=NULL)
    {
        Thread(p->lchild);          //×ó×ÓÊ÷ÏßË÷»¯
        if (p->lchild==NULL)        //Ç°ÇýÏßË÷
        {
            p->lchild=pre;          //½¨Á¢µ±Ç°½áµãµÄÇ°ÇýÏßË÷
            p->ltag=1;
        }
        else p->ltag=0;
        if (pre->rchild==NULL)      //ºó¼ÌÏßË÷
        {
            pre->rchild=p;          //½¨Á¢Ç°Çý½áµãµÄºó¼ÌÏßË÷
            pre->rtag=1;
        }
        else pre->rtag=0;
        pre=p;
        Thread(p->rchild);          //ÓÒ×ÓÊ÷ÏßË÷»¯
    }
}

TBTNode *CreaThread(TBTNode *b)     //ÖÐÐòÏßË÷»¯¶þ²æÊ÷
{
    TBTNode *root;
    root=(TBTNode *)malloc(sizeof(TBTNode));  //´´½¨¸ù½áµã
    root->ltag=0;
    root->rtag=1;
    root->rchild=b;
    if (b==NULL)                //¿Õ¶þ²æÊ÷
        root->lchild=root;
    else
    {
        root->lchild=b;
        pre=root;               //preÊÇ*pµÄÇ°Çý½áµã,¹©¼ÓÏßË÷ÓÃ
        Thread(b);              //ÖÐÐò±éÀúÏßË÷»¯¶þ²æÊ÷
        pre->rchild=root;       //×îºó´¦Àí,¼ÓÈëÖ¸Ïò¸ù½áµãµÄÏßË÷
        pre->rtag=1;
        root->rchild=pre;       //¸ù½áµãÓÒÏßË÷»¯
    }
    return root;
}

void ThInOrder(TBTNode *tb)
{
    TBTNode *p=tb->lchild;      //Ö¸Ïò¸ù½áµã
    while (p!=tb)
    {
        while (p->ltag==0) p=p->lchild;
        printf("%c ",p->data);
        while (p->rtag==1 && p->rchild!=tb)
        {
            p=p->rchild;
            printf("%c ",p->data);
        }
        p=p->rchild;
    }
}

int main()
{
    TBTNode *b,*tb;
    CreateTBTNode(b,"A(B(D(,G)),C(E,F))");
    printf(" ¶þ²æÊ÷:");
    DispTBTNode(b);
    printf("\n");
    tb=CreaThread(b);
    printf(" ÏßË÷ÖÐÐòÐòÁÐ:");
    ThInOrder(tb);
    printf("\n");
    return 0;
}

二、graph.cpp

#include <stdio.h>
#include <malloc.h>
#include "graph.h"

//¹¦ÄÜ£ºÓÉÒ»¸ö·´Ó³Í¼ÖÐ¶¥µãÁÚ½Ó¹ØÏµµÄ¶þÎ¬Êý×é£¬¹¹Ôì³öÓÃÁÚ½Ó¾ØÕó´æ´¢µÄÍ¼
//²ÎÊý£ºArr - Êý×éÃû£¬ÓÉÓÚÐÎÊ½²ÎÊýÎª¶þÎ¬Êý×éÊ±±ØÐë¸ø³öÃ¿ÐÐµÄÔªËØ¸öÊý£¬ÔÚ´Ë½«²ÎÊýArrÉùÃ÷ÎªÒ»Î¬Êý×éÃû£¨Ö¸ÏòintµÄÖ¸Õë£©
//      n - ¾ØÕóµÄ½×Êý
//      g - Òª¹¹Ôì³öÀ´µÄÁÚ½Ó¾ØÕóÊý¾Ý½á¹¹
void ArrayToMat(int *Arr, int n, MGraph &g)
{
    int i,j,count=0;  //countÓÃÓÚÍ³¼Æ±ßÊý£¬¼´¾ØÕóÖÐ·Ç0ÔªËØ¸öÊý
    g.n=n;
    for (i=0; i<g.n; i++)
        for (j=0; j<g.n; j++)
        {
            g.edges[i][j]=Arr[i*n+j]; //½«Arr¿´×÷n¡ÁnµÄ¶þÎ¬Êý×é£¬Arr[i*n+j]¼´ÊÇArr[i][j]£¬¼ÆËã´æ´¢Î»ÖÃµÄ¹¦·òÔÚ´ËÓ¦ÓÃ
            if(g.edges[i][j]!=0 && g.edges[i][j]!=INF)
                count++;
        }
    g.e=count;
}

void ArrayToList(int *Arr, int n, ALGraph *&G)
{
    int i,j,count=0;  //countÓÃÓÚÍ³¼Æ±ßÊý£¬¼´¾ØÕóÖÐ·Ç0ÔªËØ¸öÊý
    ArcNode *p;
    G=(ALGraph *)malloc(sizeof(ALGraph));
    G->n=n;
    for (i=0; i<n; i++)                 //¸øÁÚ½Ó±íÖÐËùÓÐÍ·½ÚµãµÄÖ¸ÕëÓòÖÃ³õÖµ
        G->adjlist[i].firstarc=NULL;
    for (i=0; i<n; i++)                 //¼ì²éÁÚ½Ó¾ØÕóÖÐÃ¿¸öÔªËØ
        for (j=n-1; j>=0; j--)
            if (Arr[i*n+j]!=0)      //´æÔÚÒ»Ìõ±ß£¬½«Arr¿´×÷n¡ÁnµÄ¶þÎ¬Êý×é£¬Arr[i*n+j]¼´ÊÇArr[i][j]
            {
                p=(ArcNode *)malloc(sizeof(ArcNode));   //´´½¨Ò»¸ö½Úµã*p
                p->adjvex=j;
                p->info=Arr[i*n+j];
                p->nextarc=G->adjlist[i].firstarc;      //²ÉÓÃÍ·²å·¨²åÈë*p
                G->adjlist[i].firstarc=p;
            }

    G->e=count;
}

void MatToList(MGraph g, ALGraph *&G)
//½«ÁÚ½Ó¾ØÕóg×ª»»³ÉÁÚ½Ó±íG
{
    int i,j;
    ArcNode *p;
    G=(ALGraph *)malloc(sizeof(ALGraph));
    for (i=0; i<g.n; i++)                   //¸øÁÚ½Ó±íÖÐËùÓÐÍ·½ÚµãµÄÖ¸ÕëÓòÖÃ³õÖµ
        G->adjlist[i].firstarc=NULL;
    for (i=0; i<g.n; i++)                   //¼ì²éÁÚ½Ó¾ØÕóÖÐÃ¿¸öÔªËØ
        for (j=g.n-1; j>=0; j--)
            if (g.edges[i][j]!=0)       //´æÔÚÒ»Ìõ±ß
            {
                p=(ArcNode *)malloc(sizeof(ArcNode));   //´´½¨Ò»¸ö½Úµã*p
                p->adjvex=j;
                p->info=g.edges[i][j];
                p->nextarc=G->adjlist[i].firstarc;      //²ÉÓÃÍ·²å·¨²åÈë*p
                G->adjlist[i].firstarc=p;
            }
    G->n=g.n;
    G->e=g.e;
}

void ListToMat(ALGraph *G,MGraph &g)
//½«ÁÚ½Ó±íG×ª»»³ÉÁÚ½Ó¾ØÕóg
{
    int i,j;
    ArcNode *p;
    g.n=G->n;   //¸ù¾ÝÒ»Â¥Í¬Ñ§¡°¾Ù±¨¡±¸ÄµÄ¡£g.nÎ´¸³Öµ£¬ÏÂÃæµÄ³õÊ¼»¯²»Æð×÷ÓÃ
    g.e=G->e;
    for (i=0; i<g.n; i++)   //ÏÈ³õÊ¼»¯ÁÚ½Ó¾ØÕó
        for (j=0; j<g.n; j++)
            g.edges[i][j]=0;
    for (i=0; i<G->n; i++)  //¸ù¾ÝÁÚ½Ó±í£¬ÎªÁÚ½Ó¾ØÕó¸³Öµ
    {
        p=G->adjlist[i].firstarc;
        while (p!=NULL)
        {
            g.edges[i][p->adjvex]=p->info;
            p=p->nextarc;
        }
    }
}

void DispMat(MGraph g)
//Êä³öÁÚ½Ó¾ØÕóg
{
    int i,j;
    for (i=0; i<g.n; i++)
    {
        for (j=0; j<g.n; j++)
            if (g.edges[i][j]==INF)
                printf("%3s","¡Þ");
            else
                printf("%3d",g.edges[i][j]);
        printf("\n");
    }
}

void DispAdj(ALGraph *G)
//Êä³öÁÚ½Ó±íG
{
    int i;
    ArcNode *p;
    for (i=0; i<G->n; i++)
    {
        p=G->adjlist[i].firstarc;
        printf("%3d: ",i);
        while (p!=NULL)
        {
            printf("-->%d/%d ",p->adjvex,p->info);
            p=p->nextarc;
        }
        printf("\n");
    }
}

三、main.cpp

1.深度优先遍历——DFS

#include <stdio.h>
#include <malloc.h>
#include "graph.h"
int visited[MAXV];
void DFS(ALGraph *G, int v)
{
    ArcNode *p;
    int w;
    visited[v]=1;
    printf("%d ", v);
    p=G->adjlist[v].firstarc;
    while (p!=NULL)
    {
        w=p->adjvex;
        if (visited[w]==0)
            DFS(G,w);
        p=p->nextarc;
    }
}

int main()
{
    int i;
    ALGraph *G;
    int A[5][5]=
    {
        {0,1,0,1,0},
        {1,0,1,0,0},
        {0,1,0,1,1},
        {1,0,1,0,1},
        {0,0,1,1,0}
    };
    ArrayToList(A[0], 5, G);

    for(i=0; i<MAXV; i++) visited[i]=0;
    printf(" 由2开始深度遍历:");
    DFS(G, 2);
    printf("\n");

    for(i=0; i<MAXV; i++) visited[i]=0;
    printf(" 由0开始深度遍历:");
    DFS(G, 0);
    printf("\n");
    return 0;
}

测试图：

2. 广度优先遍历——BFS

#include <stdio.h>
#include <malloc.h>
#include "graph.h"

void BFS(ALGraph *G, int v)
{
    ArcNode *p;
    int w,i;
    int queue[MAXV],front=0,rear=0; //定义循环队列
    int visited[MAXV];     //定义存放节点的访问标志的数组
    for (i=0; i<G->n; i++) visited[i]=0; //访问标志数组初始化
    printf("%2d",v);            //输出被访问顶点的编号
    visited[v]=1;                       //置已访问标记
    rear=(rear+1)%MAXV;
    queue[rear]=v;              //v进队
    while (front!=rear)         //若队列不空时循环
    {
        front=(front+1)%MAXV;
        w=queue[front];             //出队并赋给w
        p=G->adjlist[w].firstarc;   //找w的第一个的邻接点
        while (p!=NULL)
        {
            if (visited[p->adjvex]==0)
            {
                printf("%2d",p->adjvex); //访问之
                visited[p->adjvex]=1;
                rear=(rear+1)%MAXV; //该顶点进队
                queue[rear]=p->adjvex;
            }
            p=p->nextarc;       //找下一个邻接顶点
        }
    }
    printf("\n");
}


int main()
{
    ALGraph *G;
    int A[5][5]=
    {
        {0,1,0,1,0},
        {1,0,1,0,0},
        {0,1,0,1,1},
        {1,0,1,0,1},
        {0,0,1,1,0}
    };
    ArrayToList(A[0], 5, G);

    printf(" 由2开始广度遍历:");
    BFS(G, 2);

    printf(" 由0开始广度遍历:");
    BFS(G, 0);
    return 0;
}