数据结构之图(图的基本操作)

由于图的基本操作的代码较多，我放到这一章来写。图可以用两种方法来存储，但是本人偏爱链表的表示方法，所以以下代码也都是是基于邻接链表的存储方式。

/*
   以下存储结构参考严蔚敏版数据结构，不懂的可以翻阅查看  
*/
const int UNDIGRAPH = 0;　　　　//无向图
const int DIGRAPH    = 1;　　　 //有向图
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;
}