深度遍歷：第一次：A->F->G->H 發現 結點 6 訪問過了指標移動
第二次：訪問 結點4(E) ->D->I->C->B

廣度遍歷：注重次序
第一次：A 入佇列 訪問A A出佇列，將 A 的所有未被訪問的鄰接點按照次序入佇列 （F）(B) 入隊
第二次：訪問 F F出佇列，將 F 所有的鄰接點按照次序入佇列
第三次：訪問 B B出佇列，將 B 所有的鄰接點按照次序入佇列

#include <iostream>
using namespace std;

/**
 這裡通過鄰接矩陣來構建鄰接表
 **/
 


#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define MAXVEX 100
#define MAXSIZE 9 /* 儲存空間初始分配量 */

typedef int Status;

typedef char VertexType;

typedef int  EdgeType; // 權值

// 鄰接矩陣結構
typedef struct{
    VertexType vex[MAXVEX]; // 頂點表

    EdgeType arc[MAXVEX][MAXVEX]; //鄰接矩陣 邊表

    int numEdges = 15
 
;

    int numVertexes = 9;

}MGraph;



// 邊表節點
typedef struct EdgeNode{

    int adjvex;     // 儲存該頂點對應的下標

    EdgeType info;

    struct EdgeNode * next;

}EdgeNode;

// 頂點節點
typedef struct VertexNode{
    // 統計每個頂點的入度
    int in;

    VertexType data;

    EdgeNode * firstedge; // 第一個指向邊表的指標

}VertexNode,AdjList[MAXVEX];

// 圖的鄰接表結構
 

typedef  struct {

    AdjList adjList;

    int numNodes,numEdges;

}GraphAdjList,*GraphAdjListLink; // 定義鄰接表的指標

/**********************/
/**
 定義用到的資料結構佇列  
 使用的是迴圈佇列 (判斷佇列滿的方法為差一個位置)
 **/
typedef struct {

    int data[MAXSIZE]; //用來存放被訪問的結點

    int front;

    int rear;

}Queue;


Status InitQueue(Queue * q){
    q->front = 0;
    q->rear = 0;
    return OK;
}

Status QueueEmpty(Queue q){
    if(q.front == q.rear)
        return TRUE;
    else
        return FALSE;
}

Status DeQueue(Queue *q,int *e){

    // 佇列空的條件判斷

    if(q->front == q->rear)
        return ERROR;

    *e=q->data[q->front];

    q->front = (q->front+1)%MAXSIZE;

    return OK;
}

Status EnQueue(Queue * Q, int e){

    // 佇列滿的條件
    if((Q->rear+1)%MAXSIZE == Q->front)

        return ERROR;

    Q->data[Q->rear] = e;

    Q->rear = (Q->rear+1)%MAXSIZE;

    return OK;
}


/************************/


/************************/
/**
 使用鄰接矩陣的構建圖
 **/


void CreateMGraph(MGraph *G){

    int i , j;

    G->numEdges = 15;

    G->numVertexes = 9;

    // 輸入頂點的結點
    G->vex[0] = 'A';
    G->vex[1] = 'B';
    G->vex[2] = 'C';
    G->vex[3] = 'D';
    G->vex[4] = 'E';
    G->vex[5] = 'F';
    G->vex[6] = 'G';
    G->vex[7] = 'H';
    G->vex[8] = 'I';

    // 鄰接矩陣初始化
    for(i = 0; i < G->numVertexes; i++ ){
        for (j = 0; j < G->numVertexes; j++) {
            G->arc[i][j] = 0;
        }
    }

    // 隨機生成圖

    G->arc[0][1] = 1;
    G->arc[0][5] = 1;

    G->arc[1][2] = 1;
    G->arc[1][8] = 1;
    G->arc[1][6] = 1;

    G->arc[2][3] = 1;
    G->arc[2][8] = 1;

    G->arc[3][4] = 1;
    G->arc[3][7] = 1;
    G->arc[3][6] = 1;
    G->arc[3][8] = 1;

    G->arc[4][5] = 1;
    G->arc[4][7] = 1;

    G->arc[5][6] = 1;

    G->arc[6][7] = 1;

    //因為構建的是無向圖，

    for(i = 0; i < G->numVertexes; i++){
        for( j = i; j < G->numVertexes; j++)
            G->arc[j][i] = G->arc[i][j];
    }

}


// 使用鄰接矩陣構建鄰接連結串列
void CreateALGraph(MGraph G, GraphAdjListLink * GL){

    int i , j;

    EdgeNode * e;

    *GL = (GraphAdjListLink)malloc(sizeof(GraphAdjList));

    (*GL)->numEdges = G.numEdges;

    (*GL)->numNodes = G.numVertexes;

    // 生成頂點表
    for(i= 0;i <G.numVertexes;i++) /* 讀入頂點資訊,建立頂點表 */
    {
        (*GL)->adjList[i].in=0;
        (*GL)->adjList[i].data=G.vex[i];
        (*GL)->adjList[i].firstedge=NULL;   /* 將邊表置為空表 */
    }


    // 生成鄰接表
    for(i = 0; i < G.numVertexes; i++){
        for (j = 0; j < G.numVertexes; j++) {
            if(G.arc[i][j] == 1){

                e = (EdgeNode * )malloc(sizeof(EdgeNode));

                e->adjvex = j;

                e->next = (*GL)->adjList[i].firstedge;


                (*GL)->adjList[i].firstedge = e;
                (*GL)->adjList[j].in ++ ; // 頂點入度加1

            }
        }
    }

}

/*********************/

/**********************／
/** 深度優先相關 遍歷所有結點**/

/** 過程:
    1. 依次遍歷頂點表的每個頂點，防止非連通圖的出現
    2. 如果該頂點沒有訪問，則訪問該頂點，
    3. 找到與該頂點相連的第一個臨界點，進行遞迴，結束條件是 p 的臨界點為空
    4. 繼續從第一個頂點的第二個鄰接點進行遍歷
 **/

bool visited[MAXSIZE];

void DFS(GraphAdjListLink GL,int pos){

    EdgeNode *p;

    visited[pos] = true;

    cout<<GL->adjList[pos].data<<endl;

    p = GL->adjList[pos].firstedge;

    while (p) {

        if(!visited[p->adjvex])
            DFS(GL, p->adjvex);

        p = p->next;
    }
}

void DFSTraverse(GraphAdjListLink GL){
    int i;
    for(i = 0; i < (GL)->numEdges; i++)
        visited[i] = FALSE;
    for (i = 0; i < GL->numNodes; i++) {
        if(visited[i] == FALSE){
            DFS(GL,i);
        }
    }

}


/**********************/
// 鄰接表的廣度遍歷演算法

/** 過程：1. 依次從頂點表開始遍歷 防止非連通圖的出現
         2. 判斷結點有沒有被訪問
         3. 沒有被訪問則進入佇列
         4. 判斷佇列是否為空，如果不為空，出佇列，並且將與頂點直接相連的所有臨近點按照順序入佇列
         5. 重複 1 - 4 的過程
**/
void BFSTraverse(GraphAdjListLink GL){

    int i;

    EdgeNode *p;

    Queue Q;

    for(i =0; i < GL->numNodes; i++)
        visited[i] = FALSE;

    InitQueue(&Q);

    for(i = 0; i < GL->numNodes; i++){

        if(!visited[i]){

            visited[i] = true;

            cout<<GL->adjList[i].data<<endl;

            EnQueue(&Q, i);

            while (!QueueEmpty(Q)) {

                DeQueue(&Q, &i);

                p = GL->adjList[i].firstedge;

                while (p) {

                    if(!visited[p->adjvex]){

                        visited[p->adjvex] = true;

                        cout<<GL->adjList[p->adjvex].data<<endl;

                        EnQueue(&Q, p->adjvex);
                    }

                    p = p->next;
                }

            }
        }
    }

}


int main(int argc, const char * argv[]) {

    MGraph G;
    GraphAdjListLink GL;
    CreateMGraph(&G);
    CreateALGraph(G,&GL);

    printf("\n深度遍歷:");
    DFSTraverse(GL);
    printf("\n廣度遍歷:");
    BFSTraverse(GL);
    return 0;


    return 0;
}