首先我們要知道鄰接表的基本思想：

鄰接表儲存的基本思想：對於圖的每個頂點vi，將所有鄰接於vi的頂點鏈成一個單鏈表，稱為頂點vertex的邊表（對於有向圖則稱為出邊表），所有邊表的頭指標和儲存頂點資訊的一維陣列構成了頂點表。

在這裡我打算將一個無向圖的鄰接表的建立，以及相應的深度優先搜尋和廣度優先搜尋

首先我們要明白一個鄰接表是什麼樣的，看下面這個圖：

這是一個無向圖，與之對應的鄰接表如下：

可以看到最左邊縱向的一排結點和右邊的結點有所區別

在鄰接表中，我們將其分為兩個部分：

頂點結點與邊結點

其中頂點結點的寫法如下：

class vertex				//頂點類 
    {
        public:
        char data;			//頂點資訊 
        edge *firstedge;		//頂點指向邊的指標
        vertex() {firstedge = NULL;}
    };
 

邊結點的寫法如下：

class edge				//邊類 
    {
        public:
        int adjvex;			//該邊所指向的點的資訊 
        edge *nextedge;			//指向下一條邊
        edge() {nextedge = NULL;}
        //int weight;<span style="white-space:pre">			</span>//權值
    };

從圖解中可以看出，左邊縱向的一列是頂點資訊，頂點採用順序表的方式儲存，每個頂點對應的一個橫行是從該頂點出發所能到達的所有點對應的邊

整個圖結構大致如下（不包含函式）：

class graph						//圖類 
{
    public:
    class edge					//邊類 
    {
        public:
        int adjvex;				//該邊所指向的點的資訊 
        edge *nextedge;			//指向下一條邊
        edge() {nextedge = NULL;}
        int weight;
    };
    class vertex				//頂點類 
    {
        public:
        char data;				//頂點資訊 
        edge *firstedge;		//頂點指向邊的指標
        vertex() {firstedge = NULL;}
    };
 

接下來給個原始碼：

/*************************************************************************
	> File Name: graph.cpp
	> Author: James
	> Mail: [email protected]
	> Created Time: Wed 09 Dec 2015 11:23:55 AM GMT
 ************************************************************************/

#define MAX 20
#define TRUE 1
#define FALSE 0
#include<iostream>

using namespace std;
class graph						//圖類 
{
    public:
    class edge					//邊類 
    {
        public:
        int adjvex;				//該邊所指向的點的資訊 
        edge *nextedge;			//指向下一條邊
        edge() {nextedge = NULL;}
        int weight;
    };
    class vertex				//頂點類 
    {
        public:
        char data;				//頂點資訊 
        edge *firstedge;		//頂點指向邊的指標
        vertex() {firstedge = NULL;}
    };

    graph();					//建立圖的建構函式 
    ~graph(){};					//解構函式 
    void print();				//列印圖的資訊 
    int getPosition(char ch);	//確定輸入的邊的頂點 
    void linkList(edge *before, edge *after);	//連線一個頂點的多條邊 
    char readChar();			//讀入資料 
    void DFS(graph *G,int vertexnum);
    void BFS(graph *G,int vertexnum);
    private:
    int vexnum;					//頂點總數 
    int edgnum;					//邊總數 
    vertex vexs[MAX];			//陣列形式的頂點 
};
int DFSvisited[MAX] = {FALSE};
int BFSvisited[MAX] = {FALSE};

typedef struct QNode			//隊中結點結構 
{
    int data;
    struct QNode *next;
}QNode, *QueuePtr;

typedef struct					  //隊的結構 
{
    QueuePtr front;   		   	 //隊頭指標
    QueuePtr rear;  			 //隊尾指標
}LinkQueue;		


int InitQueue(LinkQueue *Q)		 //初始化隊 
{
    Q->front = Q->rear = new QNode;
    if (!Q->front)				 
    {
        return -1;
    }
    Q->front->next = NULL;
    return 0;
}
int EnQueue(LinkQueue *Q, int e)//入隊 
{
    QueuePtr p = new QNode;
    if (!p)
    {
        return -1;
    }
    p->data = e;
    p->next = NULL;
    Q->rear->next = p;			//最後一個結點指向新加入的結點p 
    Q->rear = p;				//隊尾指標指向新加入的結點p 
    return 0;
}

int DeQueue(LinkQueue *Q)	//出隊 
{	
    QueuePtr p;
    if (Q->front == Q->rear)
    {
        return -1;
    }
    p = Q->front->next;				//p指向隊頭結點的下一個結點 
    int a = p->data;
    Q->front->next = p->next;		//隊頭結點直接指向下下個結點 
    if (Q->rear == p)
    {
        Q->rear = Q->front;
    }
    delete p;
    return a;
}
int QueueEmpty(LinkQueue Q)
{
    if (Q.front->next == NULL)
    {
        return TRUE;
    }
    else
    {
        return FALSE;
    }
}


int graph::getPosition(char ch)
{
        int i;
        for(i = 0; i < vexnum; i++)
            if(vexs[i].data == ch)
                return i;
        return -1;

}

char graph::readChar()
{
        char ch = 'a';
		while(!((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z')));		//頂點為字母 
		{
			cin>>ch;
		}
        return ch;

}
void graph::linkList(edge *before, edge *after)
{
    //edge *p = before;

    while(before->nextedge)
        before = before->nextedge;
    before->nextedge = after;
}

graph::graph()
{
    char c1;char c2;
    int v;int e;
    int i;int p1;int p2;
    int weight;
    edge *edge1 = NULL, *edge2 = NULL;
    cout<<"input vertex number: ";
    cin>>vexnum;
    cout<<"input edge number: ";
    cin>>edgnum;

    for(i = 0;i<vexnum;i++)				//初始化各頂點 
    {
        cout<<"vertex("<<i<<"):";
        vexs[i].data = readChar();
        vexs[i].firstedge = NULL;
    }
    for(i = 0; i<edgnum; i++)				// 讀取邊的起始頂點和結束頂點
    {
        cout << "edge(" << i << "): ";
        c1 = readChar();
        c2 = readChar();

        p1 = getPosition(c1);
        p2 = getPosition(c2);							// 初始化edge1
        cout<<"weight:";
        cin>>weight;
        edge1 = new edge();
        edge1->weight = weight;
        edge1->adjvex = p2;								//將edge1連線到p1所在連結串列的末尾
        if(vexs[p1].firstedge == NULL)
          vexs[p1].firstedge = edge1;
        else
            linkList(vexs[p1].firstedge,edge1);			// 初始化edge2
        edge2  =  new edge();
        edge2->weight = weight;
        edge2->adjvex  =  p1;								//無向圖，交換P1/P2位置重複上方操作 
        if(vexs[p2].firstedge == NULL)
          vexs[p2].firstedge = edge2;
        else
            linkList(vexs[p2].firstedge, edge2);
    }

}

void graph::print()
{
    int i,j;
    edge *node;

    cout << "List Graph:" << endl;
    for (i = 0; i < vexnum; i++)
    {
        cout << i << "(" << vexs[i].data << "): ";
        node  =  vexs[i].firstedge;
        while (node != NULL)
        {
            cout<<node->adjvex<<"-("<<node->weight<<")"<<"(" << vexs[node->adjvex].data<<")\t";
            node = node->nextedge;
        }
        cout << endl;
    }
}
void graph::DFS(graph *G,int vertexnum)			//DFS 
{
								
    edge *p;
    cout<<"visited vertex:"<<G->vexs[vertexnum].data<<endl;
    DFSvisited[vertexnum] = TRUE; 					//標記vexs[i]已訪問
    p  =  G->vexs[vertexnum].firstedge; 			//取vexs[i]邊表的頭指標
    while(p)
	{							//橫向搜尋vexs[i]的鄰接點
      if (!DFSvisited[p->adjvex])			//若vi尚未被訪問
        DFS(G,p->adjvex);				//則以p.adjvex為出發點向縱深搜尋
      p = p->nextedge; 					//找vexs[i]的下一鄰接點
	}
}

void graph::BFS(graph *G,int vertexnum)			// 以vk為起始點 
  {

    int i;								 
    LinkQueue Q;						//建立佇列 
    edge *p;
    InitQueue(&Q);						//佇列初始化
    cout<<"visited vertex:"<<G->vexs[vertexnum].data<<endl;
    BFSvisited[vertexnum]  =  TRUE;
    EnQueue(&Q,vertexnum);						//vexs[k]已訪問，將其序號入隊
    while(!QueueEmpty(Q)){				//隊非空則執行
        i = DeQueue(&Q);					//相當於vexs[i]出隊
        p = G->vexs[i].firstedge; 		//取vi的邊表頭指標
        while(p){						//橫向搜尋vexs[i]的鄰接點
            if(!BFSvisited[p->adjvex])
		     {							//橫向探測 
              cout<<"visited vertex:"<<vexs[p->adjvex].data<<endl; //向右訪問 
              BFSvisited[p->adjvex] = TRUE;
              EnQueue(&Q,p->adjvex);							//訪問過的邊序號入隊
             }//if
            p = p->nextedge;										//下一條邊 
         }//while
      }//while
   }
   
int main(void)
{
    graph *pG = NULL;
    pG = new graph();
    pG->print();
   	cout<<"DFS:"<<endl;	
    pG->DFS(pG,0);
   	cout<<"BFS:"<<endl;
    pG->BFS(pG,0);
    delete pG;
    return 0;
}

寫了寫發現還有點瑕疵

先發了吧 以後有空來填坑

歡迎指正