数据结构—图—各种算法代码

#include
using namespace std;
const int maxSize = 99999;
int v[maxSize];

int main()
{
    return 0;
}

/*
图的存储结构的定义
float MGraph[5][5];
for (int i = 0; i < 5;++i)
    for (int j = 0; j < 5; ++j)
        MGraph[i][j] = MAX;*/

//图的链式存储结构的结构体定义
typedef struct ArcNode
{
    int adjV;    //顶点
    struct ArcNode* next;
}ArcNode;    //分支结构体
typedef struct
{
    int data;
    int count;
    ArcNode* first;
}VNode;        //顶点
typedef struct
{
    VNode adjList[maxSize];
    int n, e;
}AGraph;    //图，两个变量表示边和顶点的个数

//图的深度优先遍历算法
void Visit(int a)
{
    cout << endl;
}
void DFS(int v, AGraph *G)
{
    //图的标志数组，初值为全0，当被访问过一次就置为1
    int visit[maxSize];
    visit[v] = 1;
    Visit(v);
    //取与所选顶点相关的第一条边
    ArcNode *q = G->adjList[v].first;
    while (q != NULL)
    {
        //判断q所指的边的另一边顶点是否被访问过
        if (visit[q->adjV] == 0)
            DFS(q->adjV, G);
        q = q->next;
    }    
}

//图的广度优先遍历算法
void BFS(AGraph *G, int v, int visit[maxSize])
{
    ArcNode *p;
    int que[maxSize], front = 0, rear = 0;
    int j;
    visit[v] = 1;
    Visit(v);
    rear = (rear + 1) % maxSize;
    //以顶点的数组下标代替顶点信息，下标入队，则相当于对应的顶点入队
    que[rear] = v;
    //队不空，则一直进行循环
    while (front != rear)
    {
        front = (front + 1) % maxSize;
        j = que[front];
        //p定义为a[v]所相邻的第一条边
        p = G->adjList[j].first;
        while (p!=NULL)
        {
            //检测边另一端的顶点是否访问过
            if (visit[p->adjV] == 0)
            {
                Visit(p->adjV);
                visit[p->adjV] = 1;
                rear = (rear + 1) % maxSize;
                que[rear] = p->adjV;
            }
            p = p->next;
        }
    }
}

//Prim算法求最小权值和
//参数分别为顶点个数，图(应该是[n][n].但编译器不允许使用参数，先用整数代替，起始顶点，权值和)
void Prim( int n, float MGraph[][50], int v0, float &sum)
{
    //同样应该参数是n和n，编译器不允许使用变量，先用常量代替
    //lowCost代表当前顶点到其他边的权值，vSet表示已经选中的顶点
    int lowCost[50], vSet[50];
    int v, k, min;
    //数组初始化
    for (int i = 0; i < n; i++)
    {
        lowCost[i] = MGraph[v0][i];
        vSet[i] = 0;
    }
    v = v0;
    vSet[v] = 1;
    sum = 0;

    for (int i = 0; i < n-1; i++)
    {
        //min初值设置为无穷大
        min = INFINITY;
        for (int j = 0; j < n; j++)
        {
            if (vSet[j] == 0 && lowCost[j] < min)
            {
                min = lowCost[j];
                k = j;
            }
        }
        vSet[k] = 1;
        v = k;
        sum += min;
        //新并入了顶点，需要更新每个顶点到其他顶点的lowCost值
        for (int j = 0; j < n;++j)
        if (vSet[j] == 0 && MGraph[v][j] < lowCost[j])
            lowCost[j] = MGraph[v][j];
    }
}

//Kruscal算法求最小生成树

//结构体定义
typedef struct
{
    int a, b;
    int w;
}Road;
Road road[maxSize];
//通过并查集数组找根结点

int getRoot(int p) //并查集为v[]
{
    while (p != v[p])
        p = v[p];
    return p;
}
void sort(Road road[], int e)
{
    //代表road函数按照e排序
    cout << endl;
}
void Kruscal(Road road[], int n, int e, int &sum)
{
    int a, b;
    sum = 0;
    for (int i = 0; i < n; ++i)
        v[i] = i;
    //把边数组按照权值排序
    sort(road, e);
    for (int i = 0; i < e; ++i)
    {
        a = getRoot(road[i].a);
        b = getRoot(road[i].b);
        if (a!=b)
        {
            v[a] = b;
            sum += road[i].w;
        }

    }
}

//Dijkstra最短路径
void Dijkstra(int n, float MGraph[][50], int v0, int dist[], int path[])
{
    //初始化
    int set[maxSize];
    int min, v;
    for (int i = 0; i < n; i++)
    {
        dist[i] = MGraph[v0][i];
        set[i] = 0;
        if (MGraph[v0][i] < INFINITY)
            path[i] = v0;
        else
            path[i] = -1;
    }
    set[v0] = 1; path[v0] = -1;
    //对剩余顶点进行处理
    for (int i = 0; i < n-1; i++)
    {
        //挑选距离最近的顶点，set值设置为1
        min = INFINITY;
        for (int j = 0; j < n;++j)
        if (set[j] == 0 && dist[j] < min)
        {
            v = j;
            min = dist[j];
        }
        set[v] = 1;
        //更新dist和path数组
        for (int j = 0; j < n; ++j)
        {
            if (set[j] == 0 && dist[v] + MGraph[v][j] < dist[j])
            {
                dist[j] = dist[v] + MGraph[v][j];
                path[j] = v;
            }
        }
    }
}

//Floyd最短路径
//求A和Path数组的代码
void Floyd(int n, float MGraph[][50], int Path[][50])
{
    int i, j, v;
    int A[50][50];
    for ( i = 0; i < n; i++)
    {
        for ( j = 0; j < n; j++)
        {
            A[i][j] = MGraph[i][j];
            Path[i][j] = -1;
        }
    }
    for ( v = 0; v < n; v++)
        for ( i = 0; i < n; i++)
            for ( j = 0; j < n; j++)
                if (A[i][j]>A[i][v]+A[v][j])
                {
                    A[i][j] = A[i][v] + A[v][j];
                    Path[i][j] = v;
                }    
}
//根据已定义的path数组寻找最短路径
//u为路径起点，v为路径终点
void printPath(int u, int v, int path[][maxSize])
{
    if (path[u][v] == -1)
        //直接输出
        cout << endl;
    else
    {
        int mid = path[u][v];
        printPath(u, mid, path);
        printPath(mid, v, path);
    }
}

//拓扑排序算法

int TopSort(AGraph *G)
{
    int i, j, n = 0;
    int stack[maxSize], top = -1;
    ArcNode *p;

    for ( i = 0; i < G->n; i++)
    {
        if (G->adjList[i].count == 0)
            stack[++top] = i;
    }

    while (top != -1)
    {
        i = stack[top--];
        ++n;
        std::cout << i << " ";
        
        p = G->adjList[j].first;
        while (p != NULL)
        {
            j = p->adjV;
            --(G->adjList[j].count);
            if (G->adjList[j].count == 0)
                stack[++top] = j;
            p = p->next;
        }
    }

    if (n == G->n)
        return 1;
    else
        return 0;
}