數據結構之圖(圖的基本操作)

由於圖的基本操作的代碼較多，我放到這一章來寫。圖可以用兩種方法來存儲，但是本人偏愛鏈表的表示方法，所以以下代碼也都是是基於鄰接鏈表的存儲方式。

/*
   以下存儲結構參考嚴蔚敏版數據結構，不懂的可以翻閱查看  
*/
const int UNDIGRAPH = 0;　　　　//無向圖  5 const int DIGRAPH    = 1;　　　 //有向圖  6 const int MAX_VERTEX_NUM = 20;

typedef struct ArchNode
{
    int    vertexIndex;        //該弧指向頂點在圖中頂點數組的索引，對應vertexs[20]的下標
    ArchNode *nextarc;         //指向下一條弧的指針
    InfoTypde info;            //比如弧的權重
}ArchNode;

typedef struct Vertex
{
    VertexType data;          //頂點信息
    ArchNode    *firstarc;    //指向第一條弧的指針
}Vertex;

//這樣定義圖有個壞處，一旦定義好，圖中結點的個數就固定了！
typedef struct Graph
{
    Vertex *vertexs[MAX_VERTEX_NUM];    //存儲頂點的數組,存放的是指向頂點的指針
    int vexNum;                         //當前圖中的定點數
    int arcNum;            　　　　　　　 //當前圖中的弧的個數
    int kind;           　　　　　　　　　//圖的種類，有向圖還是無向圖
}Graph;    

//圖的創建

/*
   初始條件：kind是圖的類型，目前有有向圖和無向圖 兩種.
   返回值   ：無。---大部分函數都無返回值，是對圖的引用進行操作的
*/
void createGraph(Graph *&G,int kind)
{
    if(G) G = NULL;
    G = (Graph *)malloc(sizeof(struct Graph));
    assert(NULL != G);
    for(int i = 0; i < MAX_VERTEX_NUM; ++i)
    {
        G->vertexs[i] = NULL;        //初始化指向頂點的指針為NULL
    }
    G->kind = kind;                    //設置圖的種類
    G->vexNum = 0;                    //初始化圖中頂點的個數
    G->arcNum = 0;                    //初始化圖中弧的個數
}

//圖的銷毀

/*
   初始條件：G存在
   返回值   ：無。---大部分函數都無返回值，是對圖的引用進行操作的
*/
void destoryGraph(Graph *&G)
{
    ArchNode *cur,*next;
    if(NULL == G)
        return;
    //遍歷頂點
    for(int i = 0; i < G->vexNum; ++i)
    {
        if(!G->vertexs[i])
            continue;
        next = G->vertexs[i]->firstarc;
        cur  = G->vertexs[i]->firstarc;
        while(cur)
        {
            next = cur->nextarc;
            free(cur);
            cur = next;
        }
        G->vertexs[i]->firstarc = NULL;
    }
    free(G);
    G = NULL;
}

//向圖中增加結點

//向圖中增加結點
/*
    初始條件：G存在，data是結點的數據值
*/
void addVertexToGraph(Graph *&G,VertexType data)
{
    if(G->vexNum >= MAX_VERTEX_NUM)
    {
        cout << "Too many vertex!" << endl;
        return ;
    }
    for(int i = 0; i < G->vexNum; ++i)
    {
        if(!G->vertexs[i])
            continue;
        if(G->vertexs[i]->data == data)
        {
            cout << "Already exists!" << endl;
            return;        //不允許重復            
        }
    }
    Vertex *pVeterx;
    pVeterx = (Vertex *)malloc(sizeof(struct Vertex));
    pVeterx->data = data;
    pVeterx->firstarc = NULL;
    G->vertexs[G->vexNum] = pVeterx;
    G->vexNum++;
}

//從圖中刪除一個結點

void delVertexFromGraph(Graph *&G,VertexType data)
{
    bool haveThisVertex = false;
    ArchNode *cur,*next,*temp,*pre;
    Vertex *anotherVertex;
    if(NULL == G)
        return;
    if(G->vexNum <= 0)
    {
        cout << "Have no vertex!" << endl;
        return ;
    }
    for(int i = 0; i < G->vexNum; ++i)
    {
        if(!G->vertexs[i])
            continue;
        if(G->vertexs[i]->data == data)
        {
            haveThisVertex = true;
            //以下循環用來刪除頂點所指向的弧鏈表
            next = cur = G->vertexs[i]->firstarc;
            if(G->kind == DIGRAPH)    //如果是有向圖
            {
                while(cur)
                {
                    next = cur->nextarc;
                    free(cur);
                    G->arcNum --;    //弧的個數減一
                    cur = next;
                }
                G->vertexs[i] = NULL;
            }
            else if(G->kind == UNDIGRAPH)    //如果是無向圖，這個麻煩點
            {
                while(cur)
                {
                    //找到待刪除的弧的另一個結點，將它的弧鏈表中指向被刪除結點的弧也刪掉
                    anotherVertex = G->vertexs[cur->vertexIndex];    //找到待刪除弧對應的另一個結點
                    temp = anotherVertex->firstarc,pre = NULL;
                    while(temp)                                        //這個循環是為了刪除另一個結點中保存弧信息
                    {
                        if(temp->vertexIndex == i)
                        {
                            //如果是首節點
                            if(NULL == pre)    //或者if(NULL == pre)
                            {
                                anotherVertex->firstarc = temp->nextarc;
                                free(temp);
                            }
                            else
                            {
                                pre->nextarc = temp->nextarc;
                                free(temp);
                            }
                            break;    //找到即停止循環
                        }
                        pre = temp;
                        temp = temp->nextarc;
                    }
                    next = cur->nextarc;
                    free(cur);
                    G->arcNum --;    //弧的個數減一
                    cur = next;
                }
                G->vertexs[i] = NULL;
            }
            for(int j = i; j < G->vexNum - 1; ++j)
            {
                G->vertexs[j] = G->vertexs[j + 1];
            }
            G->vertexs[j] = NULL;    //
            G->vexNum-- ;            //結點的個數減一
            break;
        }
    }
    if(!haveThisVertex)
        cout << "沒有該結點！" << endl;
}

//從圖中查找一個值為指定值的結點的索引

//初始條件：G存在，data是指定結點的數據值
int findVertexIndexInGraph(const Graph *G,VertexType data)
{
    if(NULL == G)
        return -1;
    for(int i = 0; i < G->vexNum; ++i)
    {
        if(!G->vertexs[i])
            continue;
        if(G->vertexs[i]->data == data)
        {
            return i;
            break;
        }
    }
    return -1;
}

//向圖中增加一條弧，有有向圖和無向圖之分

//初始條件：G存在，指定起始點，和弧的權重
void addArchToGraph(Graph *&G,VertexType startData,VertexType endData,InfoTypde weight = 0)
{
    ArchNode *pArchNode,*cur;
    //先要找到start和end
    if(NULL == G)
        return;
    int startVertexIndex = findVertexIndexInGraph(G,startData);
    int endVertexIndex = findVertexIndexInGraph(G,endData);
    cur = G->vertexs[startVertexIndex]->firstarc;
    while(cur)
    {
        if(cur->vertexIndex == endVertexIndex)
        {
            cout << "Already have this arch!" << endl;
            return ;
        }
        cur = cur->nextarc;
    }
    if(startVertexIndex >= 0 && endVertexIndex >= 0)
    {
        if(G->kind == DIGRAPH)                                            //如果是有向圖
        {
            pArchNode = (ArchNode *)malloc(sizeof(struct ArchNode));    //創建一個弧結點
            pArchNode->info = weight;
            pArchNode->nextarc = NULL;
            pArchNode->vertexIndex = endVertexIndex;
            cur = G->vertexs[startVertexIndex]->firstarc;
            if(NULL == cur)
            {
                G->vertexs[startVertexIndex]->firstarc = pArchNode;
            }
            else
            {
                while(cur->nextarc)
                {
                    cur = cur->nextarc;
                }
                cur->nextarc = pArchNode;
            }
            G->arcNum ++;    //弧的條數加一
        }
        else if(G->kind == UNDIGRAPH)    //如果是無向圖
        {
            pArchNode = (ArchNode *)malloc(sizeof(struct ArchNode));    //創建一個弧結點
            pArchNode->info = weight;
            pArchNode->nextarc = NULL;
            pArchNode->vertexIndex = endVertexIndex;
            cur = G->vertexs[startVertexIndex]->firstarc;
            if(NULL == cur)
            {
                G->vertexs[startVertexIndex]->firstarc = pArchNode;
            }
            else
            {
                while(cur->nextarc)
                {
                    cur = cur->nextarc;
                }
                cur->nextarc = pArchNode;
            }
            pArchNode = (ArchNode *)malloc(sizeof(struct ArchNode));    //再創建一個弧結點
            pArchNode->info = weight;
            pArchNode->nextarc = NULL;
            pArchNode->vertexIndex = startVertexIndex;
            cur = G->vertexs[endVertexIndex]->firstarc;
            if(NULL == cur)
            {
                G->vertexs[endVertexIndex]->firstarc = pArchNode;
            }
            else
            {
                while(cur->nextarc)
                {
                    cur = cur->nextarc;
                }
                cur->nextarc = pArchNode;
            }
            G->arcNum ++;    //弧的條數加一
        }
    }
    else
    {
        cout << "起點或終點不存在！" << endl;
        return ;
    }
}

//從圖中刪除一條弧

//初始條件：G存在，指定要刪除弧連接的兩個頂點
void delArchFromGraph(Graph *&G,VertexType startData,VertexType endData)
{
    ArchNode *cur,*pre;
    //先要找到start和end
    if(NULL == G)
        return;
    int startVertexIndex = findVertexIndexInGraph(G,startData);
    int endVertexIndex = findVertexIndexInGraph(G,endData);
    if(startVertexIndex >= 0 && endVertexIndex >= 0)
    {
        if(G->kind == DIGRAPH)
        {
            cur = G->vertexs[startVertexIndex]->firstarc,pre = NULL;
            while(cur)
            {
                if(cur->vertexIndex == endVertexIndex)
                {
                    break;
                }
                pre = cur;
                cur = cur->nextarc;
            }
            if(NULL == cur)
            {
                cout << "這兩個結點之間沒有弧！" << endl;
                return ;
            }
            else
            {
                if(NULL == pre)    //是首節點
                    G->vertexs[startVertexIndex]->firstarc = cur->nextarc;
                else
                    pre->nextarc = cur->nextarc;
                free(cur);
                G->arcNum --;
            }
        }
        else if(G->kind == UNDIGRAPH)
        {
            cur = G->vertexs[startVertexIndex]->firstarc,pre = NULL;
            while(cur)
            {
                if(cur->vertexIndex == endVertexIndex)
                {
                    break;
                }
                pre = cur;
                cur = cur->nextarc;
            }
            if(NULL == cur)
            {
                cout << "這兩個結點之間沒有弧！" << endl;
                return ;
            }
            else
            {
                if(NULL == pre)    //是首節點
                    G->vertexs[startVertexIndex]->firstarc = cur->nextarc;
                else
                    pre->nextarc = cur->nextarc;
                free(cur);
                //G->arcNum --;
            }

            cur = G->vertexs[endVertexIndex]->firstarc,pre = NULL;
            while(cur)
            {
                if(cur->vertexIndex == startVertexIndex)
                {
                    break;
                }
                pre = cur;
                cur = cur->nextarc;
            }
            if(NULL == cur)
            {
                cout << "這兩個結點之間沒有弧！" << endl;
                return ;
            }
            else
            {
                if(NULL == pre)    //是首節點
                    G->vertexs[endVertexIndex]->firstarc = cur->nextarc;
                else
                    pre->nextarc = cur->nextarc;
                free(cur);
                G->arcNum --;
            }
        }
    }
    else
    {
        cout << "起點或終點不存在！" << endl;
        return ;
    }
}

//深度優先遍歷

//初始條件：圖G存在
void DFSdetails(const Graph *G,int i,int satusArr[])
{
    ArchNode *cur;
    if(satusArr[i] == 1 )
        return;
    cout << G->vertexs[i]->data << " ";
    satusArr[i] = 1;
    cur = G->vertexs[i]->firstarc;
    while(cur)
    {
        DFSdetails(G,cur->vertexIndex,satusArr);
        cur = cur->nextarc;
    }
}

void DFS(const Graph *G)
{
    int satusArr[MAX_VERTEX_NUM] = {0};
    cout << "深度優先遍歷：";
    if(NULL == G)
        return;
    for(int i = 0; i < G->vexNum; ++i)
    {
        DFSdetails(G,i,satusArr);
    }
    cout << endl;
}