数据结构——图（邻接矩阵，邻接表实现）

邻接矩阵实现：

#include<bits/stdc++.h>
using namespace std;
const int MaxSize=10;
int visited[MaxSize]={0};

class MGraph
{
public:
    MGraph(char a[],int n,int e);
    ~MGraph(){};
    void DFTraverse(int v);
    void BFTraverse(int v);
private:
    int vertex[MaxSize];
    int edge[MaxSize][MaxSize];
    int vertexNum,edgeNum;

};

MGraph::MGraph(int a[],int n,int e)
{
    int i,j,k;
    vertexNum=n;
    edgeNum=e;
    for(i=0;i<vertexNum;i++){
        vertex[i]=a[i];
    }
    for(i=0;i<vertexNum;i++){
        for(j=0;j<vertexNum;j++){
            edge[i][j]=0;
        }
    }
    for(k=0;k<edgeNum;k++){
        cin>>i>>j;
        edge[i][j]=1;
        edge[j][i]=1;
    }
}

深度优先遍历

类似树的前序遍历，选择递归思想进行实现记录节点

void MGraph::DFTraverse(int v)
{
    cout<<vertex[v];
    visited[v]=1;
    for(int j=0;j<vertexNum;j++){
        if(edge[v][j]==1&&visited[j]==0)
            DFTraverse(j);
    }
}

广度优先遍历

类似树的层序遍历，同样还是队列实现

void MGraph::BFTraverse(int v)
{
    int w,j,Q[MaxSize];
    int front=-1,rear=-1;
    cout<<vertex[v];
    visited[v]=1;
    Q[++rear]=v;
    while(front!=rear){
        w=Q[++front];
        for(j=0;j<vertexNum;j++){
            if(edge[w][j]==1&&visited[j]==0){
                cout<<vertex[j];
                visited[j]=1;
                Q[++rear]=j;

            }
        }
    }
}

主函数实现

int main()
{
    int i;
    char ch[]={'A','B','C','D','E'};
    MGraph MG{ch,5,6};
    for(i=0;i<MaxSize;i++){
        visited[i]=0;
    }
    cout<<"dfs pre:"<<endl;
    MG.DFTraverse(0);
    for(i=0;i<MaxSize;i++){
        visited[i]=0;
    }
    cout<<"bfs pre:"<<endl;
    MG.BFTraverse(0);


    return 0;
}

邻接表实现：

#include<iostream>
#include<algorithm>

const int maxsize=10;
int visited[maxsize];
using namespace std;

struct edgenode{
    int adjvex;
    edgenode *next;
};
struct vertexnode{
    int vertex;
    edgenode *firstedge;
};

class algraph{
public:
    algraph(char a[],int n,int e);
    ~algraph();
    void dfs(int v);
    void bfs(int v);
private:
    vertexnode adjlist[maxsize];
    int vertexnum,edgenum;
};

algraph::algraph(char a[],int n,int e){
    int i,j,k;
    edgenode *s=NULL;
    vertexnum=n;
    edgenum=e;
    for(i=0;i<vertexnum;i++){
        adjlist[i].vertex=a[i];
        adjlist[i].firstedge=NULL;
    }
    for(k=0;k<edgenum;k++){
        cin>>i>>j;
        s=new edgenode;
        s->adjvex=j;
        s->next=adjlist[i].firstedge;
        adjlist[i].firstedge=s;
    }
}

algraph::~algraph(){
    edgenode *p=NULL,*q=NULL;
    for(int i=0;i<vertexnum;i++){
        p=q=adjlist[i].firstedge;
        while(p!=NULL){
            p=p->next;
            delete q;
            q=p;
        }
    }
}

void algraph::dfs(int v){
    int j;
    edgenode *p=NULL;
    cout<<adjlist[v].vertex;
    visited[v]=1;
    while(p!=NULL){
        j=p->adjvex;
        if(visited[j]==0) dfs(j);
        p=p->next;
    }
}

void algraph::bfs(int v){
    int w,j,Q[maxsize];
    int front=-1,rear=-1;
    edgenode *p=NULL;
    cout<<adjlist[v].vertex;
    visited[v]=1;
    Q[++rear]=v;
    while(front!=rear){
        w=Q[++front];
        p=adjlist[v].firstedge;
        while(p!=NULL){
            j=p->adjvex;
            if(visited[j]==0){
                cout<<adjlist[j].vertex;
                visited[j]=1;
                Q[++rear]=j;
            }
            p=p->next;
        }
    }
}

int main()
{
    char ch[]={'A','B','C','D','E'};
    int i;
    algraph alg(ch,5,6);
    for(int i=0;i<maxsize;i++){
        visited[i]=0;
    }
    cout<<"dfs"<<endl;
    alg.dfs(0);
    for(int i=0;i<maxsize;i++){
        visited[i]=0;
    }
    cout<<"bfs"<<endl;
    alg.bfs(0);
    return 0;
}