图的数据结构的实现与遍历(DFS,BFS)

//图的存储结构:
const int MAXSIZE = 10;
//邻接矩阵
template<class T>
class MGraph {
public:
    MGraph(T a[], int n, int e);
    void DFS(int v);
    void BFS(int v);
private:           //edge为边用来表示无向图,arc为弧用来表示有向图,vertex为顶点
    T vertex[MAXSIZE];
    int arc[MAXSIZE][MAXSIZE];
    int edge[MAXSIZE][MAXSIZE];
    int vNum, arcNum,eNum;
    bool* visited;     //DFS使用
};
template<class T>
MGraph<T>::MGraph(T a[], int v, int e) {     //n为顶点个数,e为边的个数,a[]为各顶点值
    vNum = v;            //将顶点个数,边个数,顶点值放入类中属性
    arcNum = e;
    visited = new bool[v];
    memset(visited, false, sizeof(bool) * v);
    for (int k = 0; k < v; k++) {    
        vertex[k] = a[k];
    }
    for (int k = 0; k < v; k++) {    //先将邻接矩阵初始化
        for (int j = 0; j < v; j++) {
            arc[k][j] = 0;
        }
    }
    for (int k = 0,i=0,j=0; k < e; k++) {  //这里是无向图的邻接矩阵,输入相连的两个顶点
        cin >> i >> j;
        arc[j-1][i-1] = arc[i-1][j-1] = 1;
    }
}

//邻接表,同样以无向图为例,边用arc表示
struct ArcNode {    //边的数据结构,存储边信息和下一条边
    int adjvex;   //相邻的顶点
    ArcNode* nextarc;
};
struct VertexNode {   //顶点的数据结构，存储顶点信息和下一条边
    int vertex;
    ArcNode* firstarc;
};
template<class T>
class ALGraph {
public:
    ALGraph(T a[], int n, int e);
    //~ALGraph();
    void DFS(int v);
    void BFS(int v);
private:
    VertexNode adjlist[MAXSIZE];
    int vNum, arcNum;
    bool* visited;
};
template<class T>
ALGraph<T>::ALGraph(T a[], int v, int e) {
    vNum = v;
    arcNum = e;
    visited = new bool[v];
    memset(visited, false, sizeof(bool) * v);
    for (int i = 0; i < v; i++) {  //对顶点表进行初始化
        adjlist[i].vertex = a[i];
        adjlist[i].firstarc = NULL;
    }
    for (int k = 0,i=0,j=0; k < e; k++) {  //这里是无向图,如果有向图的话,则为顶点i指向j
        cin >> i >> j;               //注意这里的e是每个顶点连接的边的总和,将无向看成有双箭头的有向(实际不适合表示无向图)
        ArcNode* s = new ArcNode;
        s->adjvex = j;                      //这里使用的是头插入法
        s->nextarc = adjlist[i-1].firstarc;
        adjlist[i-1].firstarc = s;
    }
}
//补充:邻接表适合表示有向图,还有一种逆邻接表表示法,与邻接表的出为指向方向相反,逆邻接表类似于入边表

//十字链表,只提供节点的存储结构
struct VertexNodeC {
    int Vertex;
    ArcNode* firstin;
    ArcNode* firstout;
};
struct ArcNodeC {
    int headvex,tailvex;
    ArcNode* hlink;
};

//边集数组，比较常用,使用两个一维数组存储,一个数组存储顶点,一个数组存储起点,终点,权值
struct ArcNodeE {
    int headvex;
    int tailvex;
    int weight;
};

//图的遍历:DFS与BFS
//DFS深度优先搜索,类似于二叉树的前序遍历,先从一条支路到结尾,然后一步步回溯寻找还未访问过的节点
//邻接矩阵和邻接表两种存储结构的dfs
//两种存储结构的dfs比较
//邻接矩阵的时间复杂度 n
//邻接表的时间复杂度 n+e 栈深度 n 空间复杂度 n
template<class T>
void MGraph<T>::DFS(int v) {
    cout << vertex[v];
    visited[v] = true;    //将访问过的顶点标记为访问过
    for (int j = 0; j < vNum; j++) {       //按照邻接矩阵的特性,根据标记来深入搜索
        if (arc[v][j] == 1 && visited[j] == false) {
            DFS(j);
        }
    }
}
template<class T>
void ALGraph<T>::DFS(int v) {  //根据邻接表的连接,从顶点第一个边节点转为顶点节点,并标记是否访问,然后一步步回溯看是否有未访问的相邻节点
    cout << adjlist[v].vertex;
    visited[v] = true;
    ArcNode* p = adjlist[v].firstarc;
    while (p) {
        if (visited[p->adjvex] == false) {
            DFS(p->adjvex);
        }
        p = p->nextarc;
    }
}

//BFS广度优先搜索,类似于树的层序遍历,使用队列逻辑结构
//分别用邻接矩阵和邻接表描述
//邻接矩阵时间复杂度 n
//邻接表时间复杂度 n+e 空间复杂度 n
template<class T>
void MGraph<T>::BFS(int v) {
    int queue[MAXSIZE];
    int f = 0, r = 0;
    cout << vertex[v];
    visited[v] = true;
    queue[++r] = v;
    while (f != r) {      //当头尾相等时队列为空,表示队列为空
        v = queue[++f];
        for (int j = 0; j < vNum; j++) {
            if (arc[v][j] == 1 && visited[j] == false) {
                cout << vertex[j];
                visited[j] = true;
                queue[++r] = j;
            }
        }
    }
}
template<class T>
void ALGraph<T>::BFS(int v) {
    int queue[MAXSIZE];
    int f = 0, r = 0;
    cout << adjlist[v].vertex;
    visited[v] = true;
    queue[++r] = v;
    while (r!=f) {
        v = queue[++f];
        ArcNode *p = adjlist[v].firstarc;
        while (p) {
            int j = p->adjvex;
            if (visited[j] == false) {
                cout << adjlist[j].vertex;
                visited[j] = true;
                queue[++r] = j;
            }
            p = p->nextarc;
        }
    }
}
关于图的4中基本算法放在单独一篇,Prim,Kruskal,Floyd,Dijkstra