各种基本算法实现小结（四）—— 图及其遍历

 　　
  1 // graph.cpp : 定义控制台应用程序的入口点。
//邻接矩阵表示
#include "stdafx.h"
#include <malloc.h>
#define INFINITY 32767
#define MAX_VEX 20
#define QUEUE_SIZE 20
bool *visited;                                                 //用来判断是否遍历过,为true则遍历过,为false,则未遍历过

typedef struct{        
    char* vexs;                                                //顶点向量(包含的顶点a,b,c,d ...)
    int arcs[MAX_VEX][MAX_VEX];                                //邻接矩阵
    int vexnum,arcnum;                                         //图的顶点数和弧数
}Graph;

class Queue{
public:
    Queue(){};
    virtual ~Queue(){
        delete this->base;
    }
    int* base;
    int front;
    int rear;

public:
    void InitQueue(){
        base=(int *)malloc(QUEUE_SIZE*sizeof(int));
        front=rear=0;
    }
    void EnQueue(int e){
        base[rear]=e;
        rear=((rear+1) % QUEUE_SIZE);
    }
    void DeQueue(int &e){
        e=base[front];
        front=(front+1)%QUEUE_SIZE;
    }
};


int Locate(Graph G,char c){
    for(int i=0;i<G.vexnum;i++)
        if(G.vexs[i] == c)
            return i;
    return -1;
}

void CreateUDN(Graph &G){
    int i,j,w,s1,s2;
    char a,b,temp;
    printf("输入顶点数和弧数:");
    scanf_s("%d%d",&G.vexnum,&G.arcnum);
    temp=getchar();                                            //接收回车
    G.vexs=(char*)malloc(G.vexnum*sizeof(char));
    printf("输入%d个顶点.\n",G.vexnum);
    for(i=0;i<G.vexnum;i++){
        printf("输入顶点%d:",i);
        scanf_s("%c",&G.vexs[i]);
        temp=getchar();
    }
    for(i=0;i<G.vexnum;i++)                                    //初始化邻接矩阵
        for(j=0;j<G.vexnum;j++)
            G.arcs[i][j]=INFINITY;

    printf("输入%d条弧.\n",G.arcnum);
    
    for(i=0;i<G.arcnum;i++){
        printf("输入弧%d:",i);
        scanf_s("%c %c %d",&a,1,&b,1,&w);
        temp=getchar();
        s1=Locate(G,a);
        s2=Locate(G,b);
        G.arcs[s1][s2]=G.arcs[s2][s1]=w;
    }
}

//获取图G中顶点K的第一个邻接顶点
int FirstVex(Graph G,int k){
    if(k>=0 && k<G.vexnum)            //k合理
        for(int i=0;i<G.vexnum;i++)
            if(G.arcs[k][i]!=INFINITY)
                return i;
    return -1;
}

//获取图G中以i为顶点的第j个邻接顶点的下一个邻接顶点
int NextVex(Graph G,int i,int j){
    if(i>=0 && i<G.vexnum && j>=0 && j<G.vexnum)
        for(int k=j+1;k<G.vexnum;k++)
            if(G.arcs[i][k]!=INFINITY)
                return k;
    return -1;                                                //如果遍历完还没有返回k的就返回-1;
}

void DFS(Graph G,int k){
    int i;
    if(k == -1){                                            //第一次执行DFS时,k为-1
        for(i=0;i<G.vexnum;i++)
            if(!visited[i])
                DFS(G,i);                                    //对尚未访问的顶点调用DFS
    }
    else{
        visited[k] = true;
        printf("%c ",G.vexs[k]);                            //访问第k个顶点
        for(i=FirstVex(G,k);i>=0;i=NextVex(G,k,i))            
            if(!visited[i])                                    //对k的尚未访问的邻接顶点i递归调用DFS
                DFS(G,i);        
    }
}

void BFS(Graph G){
    int k,w;
    Queue Q;                                                //辅助队列Q
    Q.InitQueue();
    for(int i=0;i<G.vexnum;i++)
        if(!visited[i]){
            visited[i]=true;
            printf("%c ",G.vexs[i]);
            Q.EnQueue(i);
            while(Q.front!=Q.rear){
                Q.DeQueue(k);
                for(w=FirstVex(G,k);w>=0;w=NextVex(G,k,w)){
                    if(!visited[w]){
                        visited[w]=true;
                        printf("%c ",G.vexs[w]);
                        Q.EnQueue(w);
                    }
                }
            }
        }
}

int _tmain(int argc, _TCHAR* argv[])
{
    int i;
    Graph G;
    CreateUDN(G);
    visited=(bool*)malloc(G.vexnum*sizeof(bool));
    
    printf("\n深度优先遍历:");
    for(i=0;i<G.vexnum;i++)
        visited[i]=false;
    DFS(G,-1);
    
    printf("\n广度优先遍历\n");
    for(i=0;i<G.vexnum;i++)
        visited[i]=false;
    
    BFS(G);
    free(G.vexs);
    printf("\n程序结束\n");
    return 0;
}

测试环境： VS 2010

运行结果：

       

本文参考自：~~~