图的相关操作

#include <iostream>
#include <algorithm>

using namespace std;
const int MaxNum = 100;
const int INF = 99999;
typedef struct srcNode {
    int Vem;
    struct srcNode * next;
} srcNode;

typedef struct vNode {
    char data;
    srcNode *src;
} vNode;

typedef struct GNode {
    int vNum, srcNum;
    vNode vNodeList[MaxNum];
} Graph, GNode;


/**
*BFS
*/
void BFS(Graph *G) {
//    广度优先遍历需要维护一个队列
    int v[MaxNum*MaxNum];
    int front = -1, rear = -1;
    bool visited[MaxNum];
    for(int i=0; i<G->vNum; ++i) {
        visited[i] = false;
    }
    v[++rear] = 0;
    while(rear!=front) {
        int vnow = v[++front];
        if(!visited[vnow]) {
//            访问
            cout<<G->vNodeList[vnow].data<<endl;
            visited[vnow] = true;
            srcNode *p = G->vNodeList[vnow].src;
            while(p) {
                v[++rear] = p->Vem;
                p = p->next;
            }

        }
    }
}

/**
*DFS
*/
void DFS(Graph *G) {
    int stack[MaxNum*MaxNum];
    int top = -1;
    bool visited[G->vNum];
    for(int i=0; i<G->vNum; ++i) {
        visited[i] = false;
    }

    stack[++top] = 0;
    while(top!=-1) {
        int vnow = stack[top--];
        if(!visited[vnow]) {
            cout<<G->vNodeList[vnow].data<<endl;
            visited[vnow] = true;
            srcNode *p = G->vNodeList[vnow].src;
            while(p) {
                stack[++top] = p->Vem;
                p = p->next;
            }
        }
    }
}

/**
*DFS递归遍历
*/
bool isvisited[MaxNum*MaxNum]= {0};
void DFS(Graph *G, int v) {
    cout<<G->vNodeList[v].data<<endl;
    isvisited[v] = true;

    srcNode *p = G->vNodeList[v].src;
    while(p) {
        if(!isvisited[p->Vem]) {
            DFS(G, p->Vem);
        }
        p = p->next;
    }
}

/**
*构造图的邻接链表
*/
Graph *createGraph(char v[], int src[][6], int n) {
    Graph *G = new Graph();
    G->srcNum = 7;
    G->vNum = 6;
    for(int i=0; i<n; i++) {
        G->vNodeList[i].data = v[i];
        G->vNodeList[i].src = NULL;

        for(int j=0; j<n; j++) {
            if(src[i][j] != INF) {
                srcNode *srcNow = new srcNode();
                srcNow->Vem = j;
                srcNow->next = G->vNodeList[i].src;
                G->vNodeList[i].src = srcNow;
            }
        }
    }
    return G;
}


/**
*最小生成树
*/
void prime(Graph *G, int src[][6]) {
//    维护两个数组
    bool isVisited[G->vNum];
//    就是结果集
    int parents[G->vNum];

//    初始化数组
    for(int i=0; i<G->vNum; i++) {
        isVisited[i] = false;
        parents[i] = -1;
    }

    isVisited[0] = true;
    int n=1;
    while(n<G->vNum) {
        int minL = INF;
        //未访问的节点和已经访问的节点，这两点构成的边
        int unvisited, visited;
        for(int i=0; i<G->vNum; ++i) {
            if(isVisited[i]) {
                visited = i;
                for(int j=0; j<G->vNum; ++j) {
                    if(!isVisited[j] && src[i][j] < minL) {
                        minL = src[i][j];
                        unvisited = j;
                    }
                }
            }

        }

        isVisited[unvisited] = true;
        parents[unvisited] = visited;
        n++;
    }

//    输出树
    for(int i=0; i<G->vNum; i++) {
        cout<<i<<":"<<parents[i]<<endl;
    }

}

/**
*Kruskal
*/
//点边对
typedef struct VS {
    int x, y;
    int length;
} VS;
int com(VS vs1, VS vs2) {
    return vs1.length>vs2.length;
}
//讲边按照长度进行排序
int VSsort(VS vsarray[], int src[][6], int vNum) {
    int top = -1;
//    将所有节点封装成点边对，装入数组
    for(int i=0; i<vNum; ++i) {
        for(int j=0; j<vNum; ++j) {
            if(src[i][j] != INF) {
                VS vsnode;
                vsnode.x = i;
                vsnode.y = j;
                vsnode.length = src[i][j];
                vsarray[++top] = vsnode;
            }
        }
    }
    sort(vsarray, vsarray+top+1, com);
    return top;
}

int findRoot(int v, int parents[]) {
    if(parents[v] == -1) {
        return v;
    }
    return findRoot(parents[v], parents);
}

bool unionV(int v1, int v2, int parents[]) {
    int v1root = findRoot(v1, parents);
    int v2root = findRoot(v2, parents);
    if(v1root == v2root) {
        return false;
    }
    parents[v1root] = v2root;
    return true;
}

void Kruskal(int src[][6], int vNum) {
    VS vsArray[MaxNum];
    int top = VSsort(vsArray, src, vNum);
    //并查集 ，并非结果集
    int parents[vNum];
    int result[vNum];
    for(int i=0; i<vNum; ++i) {
        parents[i] = -1;
        result[i] = -1;
    }

    int n=0;
    while(n < vNum-1) {
        VS vsnode = vsArray[top--];
        if(unionV(vsnode.x, vsnode.y, parents)) {
            result[vsnode.x] = vsnode.y;
            n++;
        }
    }

    //    输出树
    for(int i=0; i<vNum; i++) {
        cout<<i<<":"<<result[i]<<endl;
    }
}
/**
*多源最短路径
*/
void flyoed(int src[][6], int origition, int destination) {
    int length[6][6];
    int parents[6][6];
//    备份路径长度，不能在原来上边更改
    for(int i=0; i<6; i++) {
        for(int j=0; j<6; ++j) {
            length[i][j] = src[i][j];
            parents[i][j] = j;
        }

    }

    for(int i=0; i<6; i++) {
        for(int j=0; j<6; j++) {
            for(int k=0; k<6; k++) {
                if((length[j][i] + length[i][k]) < length[j][k]) {
                    length[j][k] = (length[j][i] + length[i][k]);
                    parents[j][k] = parents[j][i];
                }
            }
        }
    }
    cout<<length[origition][destination]<<endl;
    cout<<origition<<" ";
    int ori = origition;
    while(ori != destination) {
        cout<<parents[ori][destination]<<" ";
        ori = parents[ori][destination];
    }

}
/**
*单源最短路径
*/
void Dijkstra(int src[][6], int origition, int destination) {
    int path[6];
//    表示到目标点距离
    int length[6];
    bool isvisited[6];
    for(int i=0; i<6; i++) {
        path[i] = -1;
        length[i] = src[i][destination];
        isvisited[i] = false;
    }
    isvisited[destination] = true;
    for(int i=0; i<6; i++) {
        int nowShortestNode = destination;
//        从未收录的点中找一个到目标点距离最小的
        for(int j=0; j<6; j++){
            if(!isvisited[j] && length[j] < length[nowShortestNode]){
                nowShortestNode = j;
            }
        }
        isvisited[nowShortestNode] = true;
//        刷新其他顶点经过这个最小的点，到目标顶点的距离
        for(int j=0; j<6; j++){
            if(!isvisited[j] && (src[j][nowShortestNode] +length[nowShortestNode])< length[j]){
                length[j] = src[j][nowShortestNode] +length[nowShortestNode];
                path[j] = nowShortestNode;
            }
        }

    }

//    输出路径
    cout<<length[origition]<<endl;
    int p = origition;
    cout<<p<<" ";
    while(path[p] != -1){
        cout<<path[p]<<" ";
        p = path[p];
    }
    cout<<destination;

}
void show(Graph *G) {
    for(int i=0; i<G->vNum; i++) {
        srcNode *p = G->vNodeList[i].src;
        while(p) {
            cout<<G->vNodeList[p->Vem].data<<"  ";
            p = p->next;
        }
        cout<<endl;
    }
}

int main() {
    char v[]= {'a', 'b', 'c', 'd', 'e', 'f'};
    int src[6][6] = {

        { INF, 6,INF,INF, 7,INF},
        {  6,INF, 2, 3,INF, 5 },
        { INF, 2,INF,INF, 1, 5 },
        { INF, 3,INF,INF,INF, 4 },
        {  7,INF, 1,INF,INF,INF},
        { INF, 5, 5, 4,INF,INF},
    };

    Graph *G = createGraph(v, src, 6);
//    prime(G, src);
//    Kruskal(src, 6);
//    show(G);
//    BFS(G);
//    DFS(G);
//    cout<<"**********************"<<endl;
//    DFS(G, 0);
    flyoed(src,5, 4);
    cout<<endl;
    Dijkstra(src, 5, 4);
}