【数据结构】——【图】算法代码实现（C/C++语言实现）（整理不易，请多关注）

最新推荐文章于 2023-10-31 14:27:58 发布
最新推荐文章于 2023-10-31 14:27:58 发布
阅读量575 收藏 5
点赞数 1
分类专栏： 数据结构 文章标签： c语言 c++ 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51795098/article/details/124790616
版权

目录

1.用图邻接矩阵表示实现的一些基本运算

2.用图邻接表表示实现的一些基本运算

3.用邻接矩阵表示的图的广度优先遍历算法

4.用邻接表表示的图的广度优先遍历算法

5.用邻接矩阵表示的图的深度优先遍历的递归算法

6.用邻接矩阵表示的图的深度优先遍历的非递归算法

7.用邻接表表示的图的深度优先遍历的非递归算法

8.用邻接矩阵表示的图的Kruskal算法

9.用邻接矩阵表示的图的prim算法

10.用邻接矩阵表示的图的Dijkstra算法

11.用邻接矩阵表示的图的Floyd算法

12.用邻接表表示图的拓扑排序算法

13.用邻接矩阵表示图的拓扑排序算法

14.图的关键路径问题的算法

1.用图邻接矩阵表示实现的一些基本运算


#define MAXVEX 20
#define NON -1

typedef char VexType;

typedef float AdjType;

typedef struct {
    int n;                                 /* 图的顶点个数 */
    VexType vexs[MAXVEX];                 /*  顶点信息 */
    AdjType arcs[MAXVEX][MAXVEX];           /* 边信息 */
} GraphMatrix;

int firstVertex(GraphMatrix* pgraph) 
{    
    return pgraph->n == 0 ? NON : 0;
}

int nextVertex(GraphMatrix* pgraph,int n) 
{    
    return n == pgraph->n-1 ? NON : n+1;
}

int firstAdjacent(GraphMatrix* pgraph, int i) 
{
    int k;
    for (k = 0; k < pgraph->n; k++)
        if(pgraph->arcs[i][k] != 0) return k;
    return NON; 
}  

int  nextAdjacent(GraphMatrix* pgraph, int i, int j) 
{
    int k;
    for (k = j+1; k < pgraph->n; k++)
        if (pgraph->arcs[i][k] != 0) return k;
    return NON; 
}   


int main() 
{
    return 0;
}

2.用图邻接表表示实现的一些基本运算


#include<stdio.h>
#define MAXVEX 20
#define NON -1

typedef char VexType;

typedef float AdjType;

typedef int Vertex;

struct EdgeNode;
typedef struct EdgeNode * PEdgeNode;
typedef struct EdgeNode * EdgeList;

struct EdgeNode {
    int endvex;                /* 相邻顶点字段 */
    AdjType weight;            /* 边的权，非带权图可以省略 */
    PEdgeNode nextedge;        /* 链字段 */
};                          /* 边表中的结点 */
                                      
typedef struct {
    VexType vertex;            /* 顶点信息 */
    EdgeList edgelist; /* 边表头指针 */
} VexNode;               /* 顶点表中的结点 */

typedef struct {
        int n;                         /* 图的顶点个数 */
        VexNode vexs[MAXVEX];
} GraphList;

int firstVertex(GraphList* pgraph) 
{    
    return pgraph->n == 0 ? NON : 0;
}

int nextVertex(GraphList* pgraph,int n) 
{    
    return n == pgraph->n-1 ? NON : n+1;
}

int firstAdjacent(GraphList* pgraph, int i) 
{
    if (pgraph->vexs[i].edgelist != NULL)
        return pgraph->vexs[i].edgelist->endvex;
    else return NON; 
}  

int nextAdjacent(GraphList* pgraph, int i, int j) 
{
    PEdgeNode p;
    for (p = pgraph->vexs[i].edgelist; p != NULL; p = p->nextedge)
        if (p->endvex == j) 
{
            if (p->nextedge != NULL)
                return p->nextedge->endvex;
            else 
                return NON;
        }
    return NON; 
}   


int main()  
{
    return 0;
}

3.用邻接矩阵表示的图的广度优先遍历算法


#include<stdio.h>
#include<stdlib.h>

#define MAXVEX 6
#define MAX 0

typedef char VexType;
typedef float AdjType;

typedef struct {
    int n;                                           /* 图的顶点个数 */
    /*VexType vexs[MAXVEX];                   顶点信息 */
    AdjType arcs[MAXVEX][MAXVEX];           /* 边信息 */
} GraphMatrix;

#define  MAXNUM   8/* 队列中最大元素个数 */
typedef int DataType;
struct  SeqQueue {             /* 顺序队列类型定义 */
    int  f, r;
    DataType  q[MAXNUM];
};

typedef  struct SeqQueue  *PSeqQueue; /* 顺序队列类型的指针类型 */

PSeqQueue  createEmptyQueue_seq( void ) 
{  
    PSeqQueue paqu;
    paqu = (PSeqQueue)malloc(sizeof(struct SeqQueue));
    if (paqu == NULL)
        printf("Out of space!! \n");
    else 
        paqu->f = paqu->r = 0;

    return paqu;
}

int isEmptyQueue_seq( PSeqQueue paqu ) 
{
    return paqu->f == paqu->r;
}

/* 在队列中插入一元素x */
void  enQueue_seq( PSeqQueue paqu, DataType x ) 
{
    if( (paqu->r + 1) % MAXNUM == paqu->f  )
        printf( "Full queue.\n" );
    else {
        paqu->q[paqu->r] = x;
        paqu->r = (paqu->r + 1) % MAXNUM;
    }
}

/* 删除队列头部元素 */
void  deQueue_seq( PSeqQueue paqu ) 
{
    if( paqu->f == paqu->r )
        printf( "Empty Queue.\n" );
    else
        paqu->f = (paqu->f + 1) % MAXNUM;
}

/* 对非空队列,求队列头部元素 */
DataType  frontQueue_seq( PSeqQueue paqu ) 
{
    return (paqu->q[paqu->f]);
}

#define NON  -1

int firstVertex(GraphMatrix* pgraph) 
{    
    if (pgraph->n == 0)
        return NON;
    else return 0;

}

int nextVertex(GraphMatrix* pgraph,int n) 
{    
    if (n == pgraph->n-1)
        return NON;
    else return n + 1;
}

int firstAdjacent(GraphMatrix* pgraph, int i) 
{
    int k;
    for (k = 0; k < pgraph->n; k++)
        if(pgraph->arcs[i][k] != 0) return k;
    return NON; 
}  


int nextAdjacent(GraphMatrix* pgraph, int i, int j) 
{
    int k;
    for (k = j+1; k < pgraph->n; k++)
        if (pgraph->arcs[i][k] != 0) return k;
    return NON; 
}   

typedef int Vertex;
#define TRUE 1
#define FALSE 0

int visited[MAXVEX];

void bfs ( GraphMatrix* g , Vertex v );
void bft ( GraphMatrix* g ) 
{
    Vertex v ;
    for ( v =firstVertex ( g ) ; v != NON ; v = nextVertex ( g , v ) )
        if ( visited[v] == FALSE ) bfs ( g , v ) ;
} 

void bfs ( GraphMatrix* g , Vertex v ) 
{
    Vertex v1 , v2;
    PSeqQueue q = createEmptyQueue_seq();       /* 队列元素的类型为Vertex* */

    enQueue_seq ( q, v ) ;
    printf("%d ", v);
    visited[v] = TRUE ;

while ( !isEmptyQueue_seq(q) ) 
{
        v1 = frontQueue_seq ( q ) ;
        deQueue_seq ( q );
        v2 = firstAdjacent ( g, v1 );

        while ( v2!= NON ) {
            if ( visited[v2] == FALSE ) 
{
                enQueue_seq ( q,  v2 );
                visited[v2] = TRUE ;
                printf("%d ", v2);
            }
            v2 = nextAdjacent ( g, v1 , v2 ) ;
        }
    }
}

GraphMatrix graph = {
    6,
    {{0,10,MAX,MAX,19,21},
     {10,0,5,6,MAX,11},
     {MAX,5,0,6,MAX,MAX},
     {MAX,6,6,0,18,14},
     {19,MAX,MAX,18,0,33},
     {21,11,MAX,14,33,0}
    }
};

int main()
{
    bft(&graph);
    return 0;
}

4.用邻接表表示的图的广度优先遍历算法


#include<stdio.h>
#include<stdlib.h>
#define MAXVEX 20

typedef struct EdgeNode EdgeNode;
typedef struct EdgeNode * PEdgeNode;
typedef struct EdgeNode * EdgeList;
struct EdgeNode {
    int endvex;                /* 相邻顶点字段 */
    PEdgeNode nextedge;        /* 链字段 */
};                                            /* 边表中的结点 */
typedef struct {
    /*VexType vertex;*/               /* 顶点信息 */
    EdgeList edgelist;         /* 边表头指针 */
} VexNode;                            /* 顶点表中的结点 */

typedef struct {
    int n;                            /* 图的顶点个数 */
    VexNode vexs[MAXVEX];
} GraphList;

/* 边的插入算法*/
void insert(GraphList* p,int a,int b) 
{
    EdgeList pp;
    PEdgeNode temp;
    temp = (PEdgeNode)malloc(sizeof(EdgeNode));
    temp->endvex = b;
    temp->nextedge = NULL;
    pp = p->vexs[a].edgelist;
        if (pp == NULL)
        p->vexs[a].edgelist = temp;
    else {
        while(pp->nextedge != NULL)
            pp = pp->nextedge;
        pp->nextedge = temp;
    }
}
        
/* 实例邻接表的构造 */
GraphList* makeList() 
{
    GraphList* p;
    int i;
    p = (GraphList*)malloc(sizeof(GraphList));
    p->n = 8;
    for (i = 0; i < p->n; i++)
        p->vexs[i].edgelist = NULL;
    insert(p,0,1);
    insert(p,0,2);
    insert(p,1,3);
    insert(p,1,4);
    insert(p,2,5);
    insert(p,2,6);
    insert(p,3,7);
    insert(p,4,7);
    insert(p,5,6);
    return p;
}


#define  MAXNUM   20/* 队列中最大元素个数 */
typedef int DataType;
struct SeqQueue {              /* 顺序队列类型定义 */
    int  f, r;
    DataType  q[MAXNUM];
};

typedef  struct SeqQueue  *PSeqQueue; /* 顺序队列类型的指针类型 */

PSeqQueue  createEmptyQueue_seq( void ) 
{  
    PSeqQueue paqu;
    paqu = (PSeqQueue)malloc(sizeof(struct SeqQueue));
    if (paqu == NULL)
        printf("Out of space!! \n");
    else 
        paqu->f = paqu->r = 0;

    return paqu;
}

int isEmptyQueue_seq( PSeqQueue paqu ) 
{
    return paqu->f == paqu->r;
}

/* 在队列中插入一元素x */
void  enQueue_seq( PSeqQueue paqu, DataType x ) 
{
    if( (paqu->r + 1) % MAXNUM == paqu->f  )
        printf( "Full queue.\n" );
else 
{
        paqu->q[paqu->r] = x;
        paqu->r = (paqu->r + 1) % MAXNUM;
    }
}

/* 删除队列头部元素 */
void  deQueue_seq( PSeqQueue paqu ) 
{
    if( paqu->f == paqu->r )
        printf( "Empty Queue.\n" );
    else
        paqu->f = (paqu->f + 1) % MAXNUM;
}

/* 对非空队列,求队列头部元素 */
DataType  frontQueue_seq( PSeqQueue paqu ) 
{
    return (paqu->q[paqu->f]);
}


#define NON -1

int  firstVertex(GraphList* pgraph) 
{    
    if (pgraph->n == 0)
        return NON;
    else return 0;
}

int  nextVertex(GraphList* pgraph,int n) 
{    
    if (n == pgraph->n - 1)
        return NON;
    else return n+1;
}

int  firstAdjacent(GraphList* pgraph, int i) 
{
    if (pgraph->vexs[i].edgelist != NULL)
        return pgraph->vexs[i].edgelist->endvex;
    else return NON; 
}  

int nextAdjacent(GraphList* pgraph, int i, int j) 
{
    PEdgeNode p;
    for (p = pgraph->vexs[i].edgelist; p != NULL; p = p->nextedge)
        if (p->endvex == j) 
{
            if (p->nextedge != NULL)
                return p->nextedge->endvex;
            else 
                return NON;
        }
    return NON; 
}   

typedef int Vertex;
#define TRUE 1
#define FALSE 0

int visited[MAXVEX];

void bfs ( GraphList* g , Vertex v );
void bft ( GraphList* g ) 
{
    Vertex v ;
    for ( v = firstVertex ( g ) ; v != NON ; v = nextVertex ( g , v ) )
        if ( visited[v] == FALSE ) bfs ( g , v ) ;
} 

void bfs ( GraphList* g , Vertex v ) 
{
    Vertex v1 , v2;
    PSeqQueue q  = createEmptyQueue_seq ( ) ;   /* 队列元素的类型为Vertex* */

    enQueue_seq ( q ,v ) ;
    printf("%d ",v);
    visited[v] = TRUE ;

while ( !isEmptyQueue_seq(q) ) 
{
        v1 = frontQueue_seq ( q ) ;
        deQueue_seq ( q );
        v2 = firstAdjacent ( g ,v1 );

        while ( v2 != NON ) {
            if ( visited[v2] == FALSE ) 
{
                enQueue_seq ( q,  v2 );
                visited[v2] = TRUE ;
                printf("%d ",v2);
            }
            v2 = nextAdjacent ( g , v1 , v2 ) ;
        }
    }
}

int main()
{
    GraphList* p = makeList();
    bft(p);
    return 0;
}

5.用邻接矩阵表示的图的深度优先遍历的递归算法


#include<stdio.h>
#define MAXVEX 6
#define MAX 0
#define NON -1

typedef char VexType;
typedef float AdjType;

typedef struct {
    int n;                                           /* 图的顶点个数 */
    /*VexType vexs[MAXVEX];                   顶点信息 */
    AdjType arcs[MAXVEX][MAXVEX];           /* 边信息 */
} GraphMatrix;


int  firstVertex(GraphMatrix* pgraph) 
{    
    if (pgraph->n == 0)
        return NON;
    else return 0;
}

int  nextVertex(GraphMatrix* pgraph,int n) 
{    
    if (n == pgraph->n-1)
        return NON;
    else return n+1;
}

int  firstAdjacent(GraphMatrix* pgraph, int i) 
{
    int k;
    for (k = 0; k < pgraph->n; k++)
        if (pgraph->arcs[i][k] != 0) return k;
    return NON; 
}  

int  nextAdjacent(GraphMatrix* pgraph, int i, int j) 
{
    int k;
    for(k=j+1; k<pgraph->n; k++)
        if(pgraph->arcs[i][k]!=0) return k;
    return NON; 
}   

typedef int Vertex;
#define TRUE 1
#define FALSE 0

int visited[MAXVEX];
void dfs ( GraphMatrix* g , Vertex v );

void dft ( GraphMatrix* g ) 
{
    Vertex v ;
    for ( v =firstVertex ( g ) ; v != NON ; v = nextVertex ( g , v ) )
        if ( visited[v] == FALSE ) dfs ( g , v ) ;
}

void dfs ( GraphMatrix* g , Vertex v ) 
{
    Vertex v1;
    visited[v] = TRUE ;
    printf("%d ",v);
    for ( v1 = firstAdjacent(g , v); v1 != NON ; v1=nextAdjacent(g ,v, v1) )
        if(visited[v1]==FALSE) dfs ( g ,v1 );
}

GraphMatrix graph = {
    6,
    {{0,10,MAX,MAX,19,21},
     {10,0,5,6,MAX,11},
     {MAX,5,0,6,MAX,MAX},
     {MAX,6,6,0,18,14},
     {19,MAX,MAX,18,0,33},
     {21,11,MAX,14,33,0}
    }
};

int main()
{
    dft(&graph);
    return 0;
}

6.用邻接矩阵表示的图的深度优先遍历的非递归算法


#include<stdio.h>
#include<stdlib.h>

#define MAXVEX 6
#define MAX 0
#define  NON  -1

typedef char VexType;
typedef float AdjType;

typedef struct {
    int n;                                           /* 图的顶点个数 */
    /*VexType vexs[MAXVEX];                   顶点信息 */
    AdjType arcs[MAXVEX][MAXVEX];           /* 边信息 */
} GraphMatrix;


int  firstVertex(GraphMatrix* pgraph) 
{    
    if(pgraph->n == 0)
        return NON;
    else return 0;
}

int  nextVertex(GraphMatrix* pgraph,int n) 
{    
    if(n==pgraph->n-1)
        return NON;
    else return n+1;
}

int  firstAdjacent(GraphMatrix* pgraph, int i) 
{
    int k;
    for(k=0;k<pgraph->n;k++)
        if(pgraph->arcs[i][k]!=0) return k;
    return NON; 
}  

int  nextAdjacent(GraphMatrix* pgraph, int i, int j) 
{
    int k;
    for(k=j+1; k<pgraph->n; k++)
        if(pgraph->arcs[i][k]!=0) return k;
    return NON; 
}   

typedef int Vertex;
#define TRUE 1
#define FALSE 0

typedef struct {
    Vertex v;
    Vertex k;
} DataType;

#define MAXNUM 20     /* 栈中最大元素个数 */
struct  SeqStack {       /* 顺序栈类型定义 */
        int  t;                        /* 指示栈顶位置 */
        DataType  s[MAXNUM];
};

typedef  struct SeqStack  *PSeqStack; /* 顺序栈类型的指针类型 */

/*创建一个空栈;为栈结构申请空间，并将栈顶变量赋值为-1*/
PSeqStack  createEmptyStack_seq( void ) 
{
    PSeqStack pastack = (PSeqStack)malloc(sizeof(struct SeqStack));
    if (pastack == NULL)
        printf("Out of space!! \n");
    else
        pastack->t = -1;
    return  (pastack);
}

/*判断pastack所指的栈是否为空栈，当pastack所指的栈为空栈时，则返回1，否则返回0*/
int  isEmptyStack_seq( PSeqStack pastack ) 
{
    return pastack->t == -1;
}

/* 在栈中压入一元素x */
void  push_seq( PSeqStack pastack, DataType x ) 
{
    if( pastack->t >= MAXNUM - 1  )
        printf( "Overflow! \n" );
    else {
        pastack->t++;
        pastack->s[pastack->t] = x;
    }
}

/* 删除栈顶元素 */
void  pop_seq( PSeqStack pastack ) 
{
    if (pastack->t == -1 )
        printf( "Underflow!\n" );
    else
        pastack->t--;
}

/* 当pastack所指的栈不为空栈时，求栈顶元素的值 */
DataType  top_seq( PSeqStack pastack ) 
{
    return pastack->s[pastack->t];
}

int visited[MAXVEX];
void dfs ( GraphMatrix* g , Vertex v );

void dft ( GraphMatrix* g ) 
{
    Vertex v ;
    for ( v = firstVertex ( g ) ; v != NON ; v = nextVertex ( g , v ) )
        if ( visited[v] == FALSE ) dfs ( g , v ) ;
}

void dfs ( GraphMatrix* g , Vertex v ) 
{
    DataType element;
    Vertex v1,v2;
    PSeqStack s ;       
    s = createEmptyStack_seq ( ) ;
    element.v = v;
    element.k = firstAdjacent(g, v);
    push_seq ( s, element) ;
    printf("%d ", v);
    visited[v] = TRUE ;
while ( !isEmptyStack_seq(s) ) 
{
        element = top_seq ( s ) ;
        pop_seq ( s );
        v1 = element.v;
        v2 = element.k;
        while (v2 != NON ) {
            if ( visited[v2] == FALSE ) 
{
                element.v = v1;
                element.k = v2;
                push_seq ( s,  element);
                visited[v2] = TRUE ;
                printf("%d ", v2);
                v1 = v2;
                v2 = firstAdjacent(g, v1);
            }
            else v2 = nextAdjacent(g , v1 , v2) ;
        }
    }
}

GraphMatrix graph = {
    6,
    {{0,10,MAX,MAX,19,21},
     {10,0,5,6,MAX,11},
     {MAX,5,0,6,MAX,MAX},
     {MAX,6,6,0,18,14},
     {19,MAX,MAX,18,0,33},
     {21,11,MAX,14,33,0}
    }
};

int main(){
    dft(&graph);
    return 0;
}

7.用邻接表表示的图的深度优先遍历的非递归算法


#include<stdio.h>
#include<stdlib.h>
#define MAXVEX 20

typedef struct EdgeNode EdgeNode;
typedef struct EdgeNode * PEdgeNode;
typedef struct EdgeNode * EdgeList;
struct EdgeNode {
    int endvex;                /* 相邻顶点字段 */
    PEdgeNode nextedge;        /* 链字段 */
};                                    /* 边表中的结点 */

typedef struct {
    /*VexType vertex;*/               /* 顶点信息 */
    EdgeList edgelist;         /* 边表头指针 */
} VexNode;                            /* 顶点表中的结点 */

typedef struct {
    int n;                            /* 图的顶点个数 */
    VexNode vexs[MAXVEX];
} GraphList;

/* 边的插入算法*/
void insert(GraphList* p,int a,int b) 
{
    EdgeList pp;
    PEdgeNode temp;
    temp = (PEdgeNode)malloc(sizeof(EdgeNode));
    temp->endvex = b;
    temp->nextedge = NULL;
    pp = p->vexs[a].edgelist;
    if (pp == NULL)
        p->vexs[a].edgelist = temp;
    else {
        while (pp->nextedge != NULL)
            pp = pp->nextedge;
        pp->nextedge = temp;
    }
}
        
/* 实例邻接表的构造 */
GraphList* makeList() 
{
    GraphList* p;
    int i;
    p = (GraphList*)malloc(sizeof(GraphList));
    p->n = 8;
    for (i = 0; i < p->n; i++)
        p->vexs[i].edgelist = NULL;
    insert(p,0,1);
    insert(p,0,2);
    insert(p,1,3);
    insert(p,1,4);
    insert(p,2,5);
    insert(p,2,6);
    insert(p,3,7);
    insert(p,4,7);
    insert(p,5,6);
    return p;
}

#define NON  -1

int firstVertex(GraphList* pgraph) 
{
    if(pgraph->n == 0)
        return NON;
    else return 0;
}

int  nextVertex(GraphList* pgraph,int n) 
{    
    if (n == pgraph->n - 1)
        return NON;
    else return n+1;
}

int firstAdjacent(GraphList* pgraph, int i) 
{
    if(pgraph->vexs[i].edgelist != NULL)
        return pgraph->vexs[i].edgelist->endvex;
    else return NON; 
}  

int nextAdjacent(GraphList* pgraph, int i, int j) 
{
    PEdgeNode p;
    for(p = pgraph->vexs[i].edgelist; p != NULL; p = p->nextedge)
        if(p->endvex==j) {
            if(p->nextedge!=NULL)
                return p->nextedge->endvex;
            else 
                return NON;
        }
    return NON; 
}

typedef int Vertex;
#define TRUE 1
#define FALSE 0

typedef struct {
    Vertex v;
    Vertex k;
} DataType;

#define MAXNUM 20   /* 栈中最大元素个数 */
struct  SeqStack {     /* 顺序栈类型定义 */
    int  t;            /* 指示栈顶位置 */
    DataType  s[MAXNUM];
};

typedef  struct SeqStack  *PSeqStack; /* 顺序栈类型的指针类型 */ 

/*创建一个空栈;为栈结构申请空间，并将栈顶变量赋值为-1*/
PSeqStack  createEmptyStack_seq( void ) 
{
    PSeqStack pastack;
    pastack = (PSeqStack)malloc(sizeof(struct SeqStack));
    if (pastack == NULL)
        printf("Out of space!\n");
    else
        pastack->t = -1;
    return  (pastack);
}

/*判断pastack所指的栈是否为空栈，当pastack所指的栈为空栈时，则返回1，否则返回0*/
int  isEmptyStack_seq( PSeqStack pastack ) 
{
    return pastack->t == -1;
}

/* 在栈中压入一元素x */
void  push_seq( PSeqStack pastack, DataType x ) 
{
    if( pastack->t >= MAXNUM - 1  )
        printf( "Overflow! \n" );
    else {
        pastack->t++;
        pastack->s[pastack->t] = x;
    }
}

/* 删除栈顶元素 */
void  pop_seq( PSeqStack pastack ) 
{
    if (pastack->t == -1 )
        printf( "Underflow!\n" );
    else
        pastack->t--;
}

/* 当pastack所指的栈不为空栈时，求栈顶元素的值 */
DataType  top_seq( PSeqStack pastack ) {
    return (pastack->s[pastack->t]);
}


int visited[MAXVEX];

void dfs ( GraphList* g , Vertex v );

void dft ( GraphList* g ) {
    Vertex v ;
    for ( v = firstVertex ( g ) ; v != NON ; v = nextVertex ( g , v ) )
        if ( visited[v] == FALSE ) dfs ( g , v ) ;
}

void dfs ( GraphList* g , Vertex v ) 
{
    DataType element;
    Vertex v1, v2;
    PSeqStack s ;       
    s = createEmptyStack_seq ( ) ;
    element.v = v;
    element.k = firstAdjacent(g, v);
    push_seq(s ,element) ;
    printf("%d ", v);
    visited[v] = TRUE ;
while ( !isEmptyStack_seq(s) ) 
{
        element = top_seq ( s ) ;
        pop_seq ( s );
        v1 = element.v;
        v2 = element.k;
        while (v2 != NON ) {
            if ( visited[v2] == FALSE ) 
{
                element.v = v1;
                element.k = v2;
                push_seq (s, element);
                visited[v2] = TRUE ;
                printf("%d ", v2);
                v1 = v2;
                v2 = firstAdjacent(g, v1);
            }
            else 
                v2 = nextAdjacent(g , v1 , v2) ;
        }
    }
}

int main()
{
    GraphList* p = makeList();
    dft(p);
    return 0;
}

8.用邻接矩阵表示的图的Kruskal算法

#include<stdio.h>
#define MAXVEX 6

typedef char VexType;

typedef float AdjType;

typedef struct {
    int n;                          /* 图的顶点个数 */
    /*VexType vexs[MAXVEX];         顶点信息 */
    AdjType arcs[MAXVEX][MAXVEX];   /* 边信息 */
} GraphMatrix;

typedef struct{
    int start_vex, stop_vex;        /* 边的起点和终点 */
    AdjType weight;                 /* 边的权 */
} Edge;

Edge mst[5];

#define MAX 1e+8

void prim(GraphMatrix * pgraph, Edge mst[]) 
{
    int i, j, min, vx, vy; 
    float weight, minweight; Edge edge;

for (i = 0; i < pgraph->n-1; i++) 
{
        mst[i].start_vex = 0;
        mst[i].stop_vex = i+1;
        mst[i].weight = pgraph->arcs[0][i+1];
    }

for (i = 0; i < pgraph->n-1; i++) 
{               /* 共n-1条边 */
        minweight = MAX;  min = i;
        for (j = i; j < pgraph->n-1; j++)/* 从所有边(vx,vy)(vx∈U,vy∈V-U)中选出最短的边 */
            if(mst[j].weight < minweight) 
{
                minweight = mst[j].weight; 
                min = j;
            }

        /* mst[min]是最短的边(vx,vy)(vx∈U, vy∈V-U)，将mst[min]加入最小生成树 */
        edge = mst[min];  
        mst[min] = mst[i];   
        mst[i] = edge;
        vx = mst[i].stop_vex;            /* vx为刚加入最小生成树的顶点的下标 */

        for(j = i+1; j < pgraph->n-1; j++) { /* 调整mst[i+1]到mst[n-1] */
            vy=mst[j].stop_vex; weight = pgraph->arcs[vx][vy];
            if (weight < mst[j].weight) {
                mst[j].weight = weight;  
                mst[j].start_vex = vx;
            }
        }
    }
}

GraphMatrix graph = {
    6,
    {{0,10,MAX,MAX,19,21},
     {10,0,5,6,MAX,11},
     {MAX,5,0,6,MAX,MAX},
     {MAX,6,6,0,18,14},
     {19,MAX,MAX,18,0,33},
     {21,11,MAX,14,33,0}
    }
};

int main()
{
    int i;
    prim(&graph,mst);
    for (i = 0; i < graph.n-1; i++)
        printf("(%d %d %.0f)\n", mst[i].start_vex,
                mst[i].stop_vex, mst[i].weight);
    return 0;
}

9.用邻接矩阵表示的图的prim算法

#include<stdio.h>
#include<stdlib.h>
#define MAXVEX 6
enum{FALSE,TRUE};

typedef char VexType;
typedef float AdjType;

typedef struct {
    int n;                                           /* 图的顶点个数 */
    /*VexType vexs[MAXVEX];                   顶点信息 */
    AdjType arcs[MAXVEX][MAXVEX];           /* 边信息 */
} GraphMatrix;

typedef struct {
    int start_vex, stop_vex;              /* 边的起点和终点 */
    AdjType weight;                  /* 边的权 */
} Edge;

Edge mst[5];


#define MAX 1e+8

int kruskal(GraphMatrix  graph, Edge mst[]) 
{   
    int i, j, num = 0, start, stop;
    float minweight;
    int* status = (int *)malloc(sizeof(int)*graph.n);
    for (i = 0; i < graph.n; i++)
        status[i] = i;
    while (num < graph.n - 1){
        minweight = MAX;
        for (i = 0; i < graph.n-1; i++)
            for (j = i+1; j < graph.n; j++)
                if (graph.arcs[i][j] < minweight)
{
                    start = i; stop = j;
                    minweight = graph.arcs[i][j];
                }
        if (minweight == MAX) return FALSE;/* 不能得到最小生成树*/
        /* 加入start和stop组成的边不产生回路*/
        if (status[start] != status[stop])
{
            mst[num].start_vex = start;
            mst[num].stop_vex = stop;
            mst[num].weight = graph.arcs[start][stop];
            num++;
            j = status[stop];
            for (i = 0; i < graph.n; i++)     
                if(status[i] == j)
                    status[i] = status[start];
        }
        /* 删除start和stop组成的边*/
        graph.arcs[start][stop] = MAX;
    }          
    return TRUE;/* 能得到最小生成树*/
}

GraphMatrix graph = {
    6,
    {{0,10,MAX,MAX,19,21},
     {10,0,5,6,MAX,11},
     {MAX,5,0,6,MAX,MAX},
     {MAX,6,6,0,18,14},
     {19,MAX,MAX,18,0,33},
     {21,11,MAX,14,33,0}
    }
};

int main()
{
    int i;
    if (kruskal(graph,mst) == TRUE)
        for (i = 0; i < graph.n-1; i++)
            printf("(%d %d %.0f)\n", mst[i].start_vex,
                mst[i].stop_vex, mst[i].weight);
    return 0;
}

10.用邻接矩阵表示的图的Dijkstra算法


#include<stdio.h>
#define MAXVEX    100
                       
typedef char VexType;
typedef float AdjType;

typedef struct {
    int n;                                           /* 图的顶点个数 */
    VexType vexs[MAXVEX];                   /* 顶点信息 */
    AdjType arcs[MAXVEX][MAXVEX];           /* 边信息 */
} GraphMatrix;

typedef struct {
    VexType vertex;        /* 顶点信息 */
    AdjType length;        /* 最短路径长度 */
    int prevex;           /* 从v0到达vi(i=1,2,…n-1)的最短路径上vi的前趋顶点 */
} Path;

Path dist[6];                    /* n为图中顶点个数*/

#define MAX 1e+8

void init(GraphMatrix* pgraph, Path dist[]) 
{
    int i; 
    dist[0].length = 0;
    dist[0].prevex = 0;      
    dist[0].vertex = pgraph->vexs[0];

    pgraph->arcs[0][0] = 1;                    /* 表示顶点v0在集合U中 */

for(i = 1; i < pgraph->n; i++) 
{             /* 初始化集合V-U中顶点的距离值 */
        dist[i].length=pgraph->arcs[0][i];
        dist[i].vertex=pgraph->vexs[i];
        if (dist[i].length != MAX)
            dist[i].prevex=0;
        else  dist[i].prevex= -1;
    }
}


void dijkstra(GraphMatrix graph, Path dist[]) 
{
    int i,j,minvex;
    AdjType min;
        init(&graph,dist); /* 初始化，此时集合U中只有顶点v0*/
for(i = 1; i < graph.n; i++) 
{
        min=MAX;       minvex=0;
        for (j = 1; j < graph.n; j++) /*在V-U中选出距离值最小顶点*/
            if( graph.arcs[j][j] == 0 && dist[j].length < min ) 
{
                min=dist[j].length;  minvex=j;  
            }

        if(minvex == 0) break; /* 从v0没有路径可以通往集合V-U中的顶点 */
        graph.arcs[minvex][minvex] = 1;       /* 集合V-U中路径最小的顶点为minvex */
        for (j = 1; j < graph.n; j++) 
{      /* 调整集合V-U中的顶点的最短路径 */
            if(graph.arcs[j][j] == 1)  continue;
            if(dist[j].length > dist[minvex].length + graph.arcs[minvex][j]) 
{
                dist[j].length = dist[minvex].length + graph.arcs[minvex][j];
                dist[j].prevex = minvex;
            }
        }
    }
}

GraphMatrix graph;

void initgraph()
{
    int i,j;
    graph.n=6;
    for (i = 0; i < graph.n; i++)
        for (j = 0; j < graph.n; j++)
            graph.arcs[i][j] = (i == j ? 0 : MAX);
    graph.arcs[0][1] = 50;
    graph.arcs[0][2] = 10;
    graph.arcs[1][2] = 15;
    graph.arcs[1][4] = 5;
    graph.arcs[2][0] = 20;
    graph.arcs[2][3] = 15;
    graph.arcs[3][1] = 20;
    graph.arcs[3][4] = 35;
    graph.arcs[4][3] = 30;
    graph.arcs[5][3] = 3;
    graph.arcs[0][4] = 45;
}

int main()
{
    int i;
    initgraph();
    dijkstra(graph, dist);
    for (i = 0; i < graph.n; i++)
        printf("(%.0f %d)", dist[i].length,dist[i].prevex);
    return 0;
}

11.用邻接矩阵表示的图的Floyd算法


#include<stdio.h>
#define MAXVEX  100
#define MAX 1e+8                         

typedef char VexType;
typedef float AdjType;

typedef struct {
    int n;                                           /* 图的顶点个数 */
    VexType vexs[MAXVEX];                   /* 顶点信息 */
    AdjType arcs[MAXVEX][MAXVEX];           /* 边信息 */
} GraphMatrix;

typedef struct {
    AdjType a[MAXVEX][MAXVEX];/* 关系矩阵A，存放每对顶点间最短路径长度 */
    int nextvex[MAXVEX][MAXVEX];
                /* nextvex[i][j]存放vi到vj最短路径上vi的后继顶点的下标值 */
} ShortPath;

void floyd(GraphMatrix * pgraph, ShortPath * ppath) 
{
    int i, j, k;

    for (i = 0; i < pgraph->n; i++)
        for (j = 0; j < pgraph->n; j++) 
{
            if (pgraph->arcs[i][j] != MAX) 
                ppath->nextvex[i][j] = j;
            else ppath->nextvex[i][j] = -1;

            ppath->a[i][j] = pgraph->arcs[i][j];
        }

    for (k = 0; k < pgraph->n; k++)
        for (i = 0; i < pgraph->n; i++)
            for (j = 0; j < pgraph->n; j++) 
{ 
                if ( ppath->a[i][k] >= MAX || ppath->a[k][j] >= MAX )
                    continue;
                if ( ppath->a[i][j] > ppath->a[i][k]+ ppath->a[k][j] ) {
                    ppath->a[i][j] = ppath->a[i][k] + ppath->a[k][j];
                    ppath->nextvex[i][j] = ppath->nextvex[i][k];
                }
            }
}


GraphMatrix graph;
ShortPath path;

void init()
{
    int i,j;
    graph.n = 6;
    for(i = 0; i < graph.n; i++)
        for(j = 0; j < graph.n; j++)
            graph.arcs[i][j] = (i == j ? 0 : MAX);
    graph.arcs[0][1] = 50;
    graph.arcs[0][2] = 10;
    graph.arcs[1][2] = 15;
    graph.arcs[1][4] = 5;
    graph.arcs[2][0] = 20;
    graph.arcs[2][3] = 15;
    graph.arcs[3][1] = 20;
    graph.arcs[3][4] = 35;
    graph.arcs[4][3] = 30;
    graph.arcs[5][3] = 3;
    graph.arcs[0][4] = 45;
}

int main()
{
    int i,j;
    init();
    floyd(&graph, &path);
for (i = 0; i < graph.n; i++)
{
        for (j = 0; j < graph.n; j++)
            printf("%d ", path.nextvex[i][j]);
        putchar('\n');
    }
    return 0;
}

12.用邻接表表示图的拓扑排序算法

#include<stdio.h>
#include<stdlib.h>
#define MAXVEX 100
#define TRUE 1
#define FALSE 0

typedef struct EdgeNode EdgeNode;
typedef struct EdgeNode * PEdgeNode;
typedef struct EdgeNode * EdgeList;

struct EdgeNode {
    int endvex;                /* 相邻顶点字段 */
    PEdgeNode nextedge;        /* 链字段 */
};                                    /* 边表中的结点 */

typedef struct {
    /*VexType vertex;*/               /* 顶点信息 */
    EdgeList edgelist;         /* 边表头指针 */
} VexNode;                            /* 顶点表中的结点 */

typedef struct{
    int n;                            /* 图的顶点个数 */
    VexNode vexs[MAXVEX];
} GraphList;

typedef struct {
    int vexsno[MAXVEX];               /* 顶点在顶点表中的下标值 */
    /*VexType vexs[MAXVEX];*/  /* 顶点信息 */ 
} Topo;

/* 求出图中所有顶点的入度 */
/* 方法是搜索整个邻接表 */
void findInDegree(GraphList* g, int *inDegree)
{
    int i; PEdgeNode p;        
    for (i = 0; i < g->n; i++)
        inDegree[i] = 0;
for (i = 0; i < g->n; i++)
{
        p = g->vexs[i].edgelist;
        while (p) 
{
            ++inDegree[p->endvex];
            p = p->nextedge;
        }
    }
}

void makeNewAOV(EdgeList p, int* indegree, int* top) 
{
    int k;
while (p) 
{                        /* 删除以该顶点为起点的边 */
        k = p->endvex; 
        indegree[k]--;
        if (indegree[k] == 0) 
{        /* 将新的入度为零的边入栈 */
            indegree[k] = *top;
            *top = k; 
        }
        p = p->nextedge;
    }
}

int topoSort(GraphList * paov, Topo * ptopo) 
{
    EdgeList p;
    int i, j, nodeno = 0, top = -1;
    int indegree[MAXVEX];
    findInDegree(paov, indegree); /* 求出图中所有顶点的入度 */
    for (i = 0; i < paov->n; i++)
        if (indegree[i] == 0) 
{         /* 将入度为零的顶点入栈 */ 
            indegree[i] = top; top = i; 
        }
        while (top != -1) 
{                           /* 栈不为空 */
            j = top;
            top = indegree[top];               /* 取出当前栈顶元素 */
            /*ptopo->vexs[nodeno]=paov->vexs[j].vertex;*/ /* 将该元素输出到拓扑序列中 */
            ptopo->vexsno[nodeno++] = j;
            p = paov->vexs[j].edgelist;    /* 取该元素边表中的第一个边结点 */
            /*删除该结点,构造新的AOV网*/
            /*对indegree数组进行修改*/
            makeNewAOV(p, indegree, &top);
        }
        if (nodeno < paov->n) 
{      /* AOV网中存在回路 */
            printf("The aov network has a cycle\n");
            return FALSE;
        }
    return TRUE;
}

/* 边的插入算法*/
void insert(GraphList* p,int a,int b)
{
    EdgeList pp;
    PEdgeNode temp;
    temp = (PEdgeNode)malloc(sizeof(EdgeNode));
    temp->endvex = b;
    temp->nextedge = NULL;
    pp = p->vexs[a].edgelist;
    if (pp == NULL) p->vexs[a].edgelist = temp;
    else {
        while (pp->nextedge != NULL)
            pp = pp->nextedge;
        pp->nextedge = temp;
    }
}
        
/* 实例邻接表的构造 */
GraphList* makeList()
{
    GraphList* p;
    int i;
    p = (GraphList*)malloc(sizeof(GraphList));
    p->n = 9;
    for (i = 0; i < p->n; i++)
        p->vexs[i].edgelist = NULL;
    insert(p, 0, 2);
    insert(p, 0, 7);
    insert(p, 1, 2);
    insert(p, 1, 3);
    insert(p, 1, 4);
    insert(p, 2, 3);
    insert(p, 3, 5);
    insert(p, 3, 6);
    insert(p, 4, 5);
    insert(p, 7, 8);
    insert(p, 8, 6);
    return p;
}

Topo topo;

int main()
{
    GraphList* p;
    int i;
    p = makeList();
    if (topoSort(p, &topo) == TRUE)
        for (i = 0; i < p->n; i++)
            printf("%d ", topo.vexsno[i]);
    return 0;
}

13.用邻接矩阵表示图的拓扑排序算法


#include<stdio.h>
#include<stdlib.h>
#define MAXVEX 100
#define TRUE 1
#define FALSE 0
                                      
typedef char VexType;
typedef int AdjType;
typedef struct {
    int n;                                                           /* 图的顶点个数 */
    /*VexType vexs[MAXVEX];*/                        /* 顶点信息 */
    AdjType arcs[MAXVEX][MAXVEX];             /* 边信息 */
} GraphMatrix;

typedef struct {
    /*VexType vexs[MAXVEX];*/  /* 顶点信息 */ 
    int vexsno[MAXVEX];               /* 顶点在顶点表中的下标值 */
} Topo;

/* 求出图中所有顶点的入度 */
/* 方法是搜索整个邻接表 */
void findInDegree(GraphMatrix* g, int *inDegree) 
{
    int i, j;       
for (i = 0; i < g->n; i++) 
{
        inDegree[i] = 0;
        for (j = 0; j < g->n; j++)
            if (g->arcs[j][i]) ++inDegree[i];
    }
}

void makeNewAOV(GraphMatrix* g, int p, int* indegree, int* top) 
{
    int k;
    for (k = 0; k < g->n; k++)/* 删除以该顶点为起点的边 */
        if (g->arcs[p][k]) {
            indegree[k]--;
            if (indegree[k] == 0) 
{         /* 将新的入度为零的边入栈 */
                indegree[k] = *top;
                *top = k; 
            }
        }
}

int topoSort(GraphMatrix * paov, Topo * ptopo) 
{
    int i, j, nodeno = 0, top = -1;
    int indegree[MAXVEX];

    findInDegree(paov, indegree); /* 求出图中所有顶点的入度 */

    for (i = 0; i < paov->n; i++)
        if (indegree[i] == 0) 
{          /* 将入度为零的顶点入栈 */ 
            indegree[i] = top; top = i;
        }

while (top != -1) 
{                           /* 栈不为空 */
        j = top;
        top = indegree[top];               /* 取出当前栈顶元素 */
        /*ptopo->vexs[nodeno] = paov->vexs[j];*/ /* 将该元素输出到拓扑序列中 */
        ptopo->vexsno[nodeno++] = j;
        /* 取该元素边表中的第一个边结点 */
        /* 删除该结点,构造新的AOV网 */
        /* 对indegree数组进行修改 */
        makeNewAOV(paov, j, indegree, &top);
    }
if (nodeno < paov->n) 
{        /* AOV网中存在回路 */
        printf("The aov network has a cycle\n");
        return FALSE;
    }
    return TRUE;
}

/* 构造邻接矩阵*/
GraphMatrix* makeMatrix()
{
    GraphMatrix* p;
    int i,j;
    p = (GraphMatrix*)malloc(sizeof(GraphMatrix));
    p->n = 9;
    for (i = 0; i < p->n; i++)
        for (j = 0; j < p->n; j++)
            p->arcs[i][j] = 0;
    p->arcs[0][2] = 1;
    p->arcs[0][7] = 1;
    p->arcs[1][2] = 1;
    p->arcs[1][3] = 1;
    p->arcs[1][4] = 1;
    p->arcs[2][3] = 1;
    p->arcs[3][5] = 1;
    p->arcs[3][6] = 1;
    p->arcs[4][5] = 1;
    p->arcs[7][8] = 1;
    p->arcs[8][6] = 1;
    return p;
}

Topo topo;

int main()
{
    int i;
    GraphMatrix* p;
    p = makeMatrix();
    if (topoSort(p, &topo) == TRUE)
        for (i = 0; i < p->n; i++)
            printf("%d ", topo.vexsno[i]);
    return 0;
}

14.图的关键路径问题的算法


#include<stdio.h>
#include<stdlib.h>
#define MAXVEX 100
#define TRUE 1
#define FALSE 0

typedef struct EdgeNode EdgeNode;
typedef struct EdgeNode * PEdgeNode;
typedef struct EdgeNode * EdgeList;
typedef float AdjType;

struct EdgeNode {
    int endvex;                /* 相邻顶点字段 */
    AdjType weight;
    PEdgeNode nextedge;        /* 链字段 */
};                                            /* 边表中的结点 */

typedef struct {
    /*VexType vertex;*/                /* 顶点信息 */
    EdgeList edgelist;         /* 边表头指针 */
} VexNode;                            /* 顶点表中的结点 */

typedef struct {
    int n;                            /* 图的顶点个数 */
    VexNode vexs[MAXVEX];
} GraphList;


typedef struct {
    /*VexType vexs[MAXVEX];*/  /* 顶点信息 */ 
    int vexsno[MAXVEX];               /* 顶点在顶点表中的下标值 */
} Topo;


/* 求出图中所有顶点的入度 */
/* 方法是搜索整个邻接表 */
void findInDegree(GraphList* g, int *inDegree) 
{
    int i; 
    PEdgeNode p;        

    for (i = 0; i < g->n; i++)
        inDegree[i] = 0;

for (i = 0; i < g->n; i++) 
{
        p = g->vexs[i].edgelist;
        while(p) 
{
            inDegree[p->endvex]++; 
            p = p->nextedge; 
        }
    }
}

void makeNewAOV(EdgeList p, int* indegree, int* top) 
{
    int k;
while (p) 
{                       /* 删除以该顶点为起点的边 */
        k = p->endvex; 
        indegree[k]--;
        if (indegree[k] == 0) 
{         /* 将新的入度为零的边入栈 */
            indegree[k] = *top;
            *top = k; 
        }
        p = p->nextedge;
    }
}

/* 拓扑排序算法*/
int topoSort(GraphList * paov, Topo * ptopo) 
{
    EdgeList p;
    int i, j, nodeno = 0, top = -1;
    int indegree[MAXVEX];

    findInDegree(paov, indegree);    /* 求出图中所有顶点的入度 */
    for (i = 0; i < paov->n; i++)
        if (indegree[i] == 0) 
{        /* 将入度为零的顶点入栈 */ 
            indegree[i] = top; top = i;
        }

while (top != -1) 
{                /* 栈不为空 */
        j = top;
        top = indegree[top];               /* 取出当前栈顶元素 */
        /*ptopo->vexs[nodeno]=paov->vexs[j].vertex;*/ /* 将该元素输出到拓扑序列中 */
        ptopo->vexsno[nodeno++] = j;
        p = paov->vexs[j].edgelist;    /* 取该元素边表中的第一个边结点 */
        /*删除该结点,构造新的AOV网*/        /*对indegree数组进行修改*/
        makeNewAOV(p, indegree, &top);
    }

if (nodeno < paov->n) 
{       /* AOV网中存在回路 */
        printf("The aov network has a cycle\n");
        return FALSE;
    }
    
    return TRUE;
}

void insert(GraphList* p,int a,int b,float weight)
{
    EdgeList pp;
    PEdgeNode temp;
    temp = (PEdgeNode)malloc(sizeof(EdgeNode));
    temp->endvex = b;
    temp->nextedge = NULL;
    temp->weight = weight;
    pp = p->vexs[a].edgelist;
    if (pp == NULL)
        p->vexs[a].edgelist = temp;
else 
{
        while (pp->nextedge != NULL)
            pp = pp->nextedge;
        pp->nextedge = temp;
    }
}
        
/* 邻接表的构造*/
GraphList* makeList()
{
    GraphList* p;
    int i;
    p = (GraphList*)malloc(sizeof(GraphList));
    p->n = 9;
    for (i = 0; i < p->n; i++)
        p->vexs[i].edgelist = NULL;
    insert(p,0,1,6);
    insert(p,0,2,4);
    insert(p,0,3,5);
    insert(p,1,4,1);
    insert(p,2,4,1);
    insert(p,3,5,2);
    insert(p,4,6,9);
    insert(p,4,7,7);
    insert(p,5,7,4);
    insert(p,6,8,2);
    insert(p,7,8,4);
    return p;
}

int CriticalPath(GraphList * paoe);

/* 主程序*/
int main()
{
    GraphList* p;
    /*int i;*/
    p = makeList();
    /*if(topoSort(p,&topo)==TRUE)
        for(i=0;i<p->n;i++)
            printf("%d ",topo.vexsno[i]);*/
    if (CriticalPath(p) == FALSE)
        printf("There is no critical path!\n");
    return 0;
}


/*******************************************/
#define MAXEDGE 100 

/* 计算数组ee*/
void countee(GraphList* paoe,Topo* ptopo, AdjType* ee) 
{
    int i, j, k;
    EdgeList p;

    for (i = 0; i < paoe->n; i++) ee[i] = 0;
for (k = 0; k < paoe->n; k++) 
{       /* 求事件vj可能的最早发生时间ee(j) */
        i = ptopo->vexsno[k];
        p = paoe->vexs[i].edgelist;
        while (p != NULL) 
{
            j = p->endvex;
            if (ee[i] + p->weight > ee[j])
                ee[j] = ee[i] + p->weight;
            p = p->nextedge;
        }
    }
}


/* 计算数组le*/
void countle(GraphList * paoe,Topo* ptopo, AdjType* ee, AdjType* le) 
{
    int i, j, k;
    EdgeList p;
    for (i = 0; i < paoe->n; i++)         /* 求事件vi允许的最迟发生时间le(i) */
        le[i] = ee[paoe->n - 1];
for (k = paoe->n - 2; k >= 0; k--) 
{
        i = ptopo->vexsno[k];
        p = paoe->vexs[i].edgelist;
        while (p != NULL) 
{
            j = p->endvex;
            if( le[j] - p->weight < le[i] )
                le[i] = le[j] - p->weight;
            p = p->nextedge;
        }
    }
}

/* 计算数组e,l并输出结果*/
void counte_l(GraphList * paoe,Topo* ptopo, AdjType* ee,
                AdjType* le, AdjType* e, AdjType* l) 
{
    int i, j, k = 0;
    EdgeList p;
    /* 求活动ak的最早开始时间e(k)及最晚开始时间l(k) */
for (i = 0; i < paoe->n; i++) 
{
        p = paoe->vexs[i].edgelist;
        while (p != NULL) 
{
            j = p->endvex;
            e[k] = ee[i];
            l[k] = le[j] - p->weight;
            if (e[k] == l[k])
                printf("<v%2d, v%2d>, ", i, j);
            k++;
            p = p->nextedge;
        }
    }
}

/* 关键路径算法*/
int CriticalPath(GraphList * paoe) 
{
    AdjType ee[MAXVEX], le[MAXVEX], l[MAXEDGE], e[MAXEDGE];
    Topo topo;
    if (topoSort(paoe, &topo) == FALSE)               /* 求AOE网的一个拓扑序列 */
        return FALSE;
    countee(paoe, &topo, ee); /*计算数组ee*/
    countle(paoe, &topo, ee, le);/*计算数组le*/
    counte_l(paoe, &topo, ee, le, e, l);/*计算数组e,l并输出结果*/
    printf("\n");
    return TRUE;
}
Mr.Wu6666
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
关于图的算法，记录对于图的理解
Dallas01的博客
01-25 190
关于图的算法 文章目录关于图的算法01 深度优先遍历（Deepth_First_Search）1.1 邻接矩阵的实现1.2 邻接表的实现02 广度优先遍历（Breadth_First_Search）2.1 邻接矩阵的实现2.2 邻接表的实现03 最小生成树（Minimum Cost Spanning Tree）3.1 普利姆算法（Prim Algorithm）3.2 克鲁斯卡尔算法（Kruskal Algorithm）04 最短路径4.1 迪杰斯特拉算法（Dijkstra Algorithm）4.2 弗洛伊
CSMA/CD算法过程模拟——数组模拟信道（C/C++）
01-15
——代码完成于2021-11-12 整体思路： 用两个数组分别模拟 A->B 和B->A间通讯的信道。A、B两主机各自拥有独立线程。线程move用来模拟信道中信号的移动。线程show用于打印信道。其中线程move和show detach()后作为...
数据结构之图（C语言）
sskdspdl的博客
10-22 1841
用C语言实现图的创建与遍历
数据结构和算法——用C语言实现所有图状结构及相关算法
有术无道止于术，有道无术尚有可为。
10-31 500
用C语言实现所有图状结构及相关算法
C语言数据结构：图！
qq_42319810的博客
07-10 1203
目录一、图的基本概念 1、基本概念 2、无向图、有向图 3、简单图、多重图 4、顶点的度、入度、出度 5、顶点-顶点的关系描述 6、连通图、强连通图 7、研究图的局部--子图 8、连通分量 9、生成树 10、生成森林 11、边的权、带权图/网 12、几种形态特殊的图 13、小结二、图的存储1、邻接矩阵（空间复杂度 = O（n*n））2、邻接表3、十字矩阵 和 邻接多重表 1、十字链表法​编辑 2、十字链表法性能分析 3、邻接多重表法 4、小结三、图的基本操作 1、Adjacent(G,x,y)：判断图G是
算法：图的常见算法的实现
OceanStar的博客
01-12 730
如何理解”图“ 树和图(Graph)都是非线性表示数据结构。 我们知道，树中的元素我们称为节点，图中的元素我们就叫做顶点(vertex)。如下图：图中的一个顶点可以和任意其他顶点建立连接关系，我们把这种建立的关系叫做边(edge)。 我们生活中就有很多符合图这种结构的例子。比如社交网络就是一个非常典型的图结构。 以微信为例，我们可以把每个用户看作一个顶点。如果两个用户之间互加好友，那就在两者之间建立一条边。所以，整个微信的好友关系就可以用一张图来表示。其中，每个用户有多少好友，对应到图中，就叫做顶点的度
<4>数据结构与算法（C/C++实现）视频教程
06-10
C/C++实现数据结构与算法视频培训课程全面介绍计算机行业，基本的数据结构与算法，既有理论的深度也有实战的技法。课程全程讲师手敲代码，一步步代你走进数据结构与算法。本课程涉及的数据结构与算法有，栈，队列，...
C/C++ 学习实例 - 数据结构/算法 - 排序算法的代码实例
最新发布
06-05
vector容器 实现以下排序算法，熟悉排序算法原理、平均（最坏）时间复杂度、稳定性等指标，熟悉各排序算法应用场景。
数据结构与算法实现-C/C++开发
05-27
该存储库专用于各种数据结构和算法的实现。 数据结构和算法的实现该存储库专门致力于我到目前为止所学到的数据结构和算法的实现。 实现语言是C ++。 1.链接列表单个链接列表创建和显示单个链接列表。 在单个链接列表...
数据结构、算法与应用——C++语言描述.rar
07-25
数据结构、算法与应用——C++语言描述.rar
关于图遍历的一个算法代码
07-14
该算法为用结构体写的图算法，typedef struct groph { int data; struct groph * next; }Groph; bool IsEmpty (groph *p) { if(p==NULL) return true ; else return false; } void DESearch(Groph *,Groph *&,int&,bool[]); void BFSearch(Groph *,int,int,int &,bool[]); void main() { int Gcount=-1; for (int i=0;Gcount<=0;i++) { cout<<"请输入大于零的图节点数量:"<<endl; cin>>Gcount; } Groph *Gro=new Groph [Gcount]; int j; bool *Breaded= new bool[Gcount]; bool *Dreaded =new bool[Gcount];//标志深广度是否读取 for ( j=0;j<Gcount;j++) {
Prim算法——C/C++
Strive_LiJiaLe的博客
04-20 834
文章目录一、最小生成树二、普里姆算法算法介绍：**算法模拟：**三、算法分析问题1：如何找到给定顶点到所有顶点的最小权值边？问题2：找到最小权值边后，将这条边的尾顶点加入后，如何进行下一次最小权重边的寻找？问题1：若使用邻接矩阵实现，则在给定顶点（假设顶点编号为0）的这一行进行遍历；若使用邻接表实现，则在以给定顶点为头节点的单链表进行遍历。即初始化给定节点到所有边的权值，将每个权重存入权重数组，最后对数组遍历，求最小权重边。问题2：找到最小权重边后，就可以将新的顶点（假设编号为1）加入，需要从已加入的所有顶
2022版王道数据结构算法题C语言代码实现-第6章-图
DanielSYC的博客
10-16 649
概述 这是2022版王道数据结构的第6章——图的算法大题的C语言代码实现，书上的练习题主要针对图的遍历且题目很少。代码都经过了简单的测试，基本上不会有太大问题。 编译环境为gcc (Ubuntu 7.5.0-3ubuntu1~18.04) 7.5.0，文件目录结构如下： ch6 ├── 6-3-graph_traversal.c ├── 6-3-graph_traversal_test.c ├── graph_adjacency_list.h ├── graph_adjacency_matrix.h ├──
图的邻接矩阵存储 C语言实现BFS
weixin_41883890的博客
06-29 559
图的邻接矩阵存储，以及在此基础上实现的广度优先遍历（BFS） /图的邻接矩阵+广度优先遍历/ #include #include#define INFINITE 65535 #define MaxSize 100typedef char VertexType; typedef int EdgeType; typedef int ElemType;typedef struct{ ElemType data[MaxSize]; int front, rear; }SqQue...
【数据结构】图的操作算法
慢热型网友的博客
06-12 489
1. 编写一个程序，输出下面带权有向图的邻接表，并根据该邻接表，实现图的遍历运算，具体要求如下： (1)从顶点0开始的深度优先遍历序列(递归算法) (2)从顶点0开始的广度优先遍历序列 2. 采用狄克斯特拉算法（Dijkstra）,输出下面有向带权图G中从顶点0到其它各顶点的最短路径和最短路径长度。...
数据结构相关C语言代码
YXXXYX的博客
04-14 1680
顺序存储结构 #include<stdio.h> #include<stdlib.h> typedef struct Arr { int *pBase;//第一个下标的地址 （类似于数组名） int lenth;//总长度（最多可存储数据） int cnt;//实际数据长度 }*PARR,ARR; void init(PARR pArr,int len);//初始化数组 void show_arr(PARR pArr);//输出数组 bool is_empty(P
数据结构之图的两种遍历实现（C语言版）
m0_63932570的博客
05-04 2803
上一期文章分享完了图的两种遍历方式，也是两种很重要的算法——DFS和BFS。这两种算法的应用和重要性我就不多说了，内行的人懂的都懂。今天这文章重要就是来上机实现这两种算法，又由于这两种算法都可以由邻接矩阵和邻接表来表示，博主分享的代码都是上机测试过的，在vs2019（其他编译器我不知道行不行）上都是可以运行的。 1.深度优先搜索（DFS）: ...
图的最小生成树——Kruskal算法
weixin_33989058的博客
12-02 703
Kruskal算法的思想如下 假设有n个顶点的连通图。首先先构造有顶点构成的集合0，每个顶点都是一个集合，不含有任何边。 在边找一个最小权值的边 判断这个边的俩个顶点是否来自于两个不同的集合，若是就将它俩归并为一个集合，然后将这个边添加到要构成的图的集合中。 直到上述的边的个数为顶点个数-1；否则，重复2-3；算法构成树的过程如下： 如a图所示的图，...
2022-2-22 数据结构—图—上(c语言代码)
名幕新星的博客
02-22 297
1. 什么是图 表示”多对多”的关系 包含 一组顶点：通常用 V（Vertex）表示顶点集合 一组边：通常用 E（Edge）表示边的集合 边是顶点对：（v,w）∈ E，其中 v,w ∈ V v—w 有向边 <v,w> 表示从 v 指向 w 的边（单行线） v→w 不考虑重边和自回路 2. 常见术语 无向图：图中所有的边无所谓方向 有向图：图中的边可能是双向，也可能是单向的，方向是很重要的 权值：给图中每条边赋予的值，可能有各种各样的现实意义 网络：带权值的图 邻接点：有边直接相连的顶点 出度：从
理解图的各种基本运算算法
05-25
图的基本运算算法主要包括以下几种： 1. 图的遍历算法：包括深度优先搜索算法（DFS）和广度优先搜索算法（BFS）。DFS 通过递归方式遍历图的所有节点，先访问当前节点的一个邻居节点，再访问其它邻居节点，直到访问完所有邻居节点后回溯到上一层节点；BFS 基于队列实现，从起始节点开始，依次遍历该节点的所有邻居节点，再访问这些邻居节点的邻居节点，直到遍历完所有节点。 2. 最短路径算法：包括 Dijkstra 算法和 Floyd-Warshall 算法。Dijkstra 算法使用贪心策略，从起始节点开始，选择距离最近的未被访问的节点，并更新与该节点相邻的节点的最短路径；Floyd-Warshall 算法则是一种动态规划算法，用于求解所有节点之间的最短路径。 3. 最小生成树算法：包括 Prim 算法和 Kruskal 算法。Prim 算法从任意一个节点开始，选择与该节点相邻的最小权重的边，并扩展生成树；Kruskal 算法则是基于边的贪心算法，将边按照权重从小到大排序，依次加入生成树中，直至所有节点都被包含在生成树中。 4. 拓扑排序算法：用于有向无环图（DAG）中，对所有节点进行排序。拓扑排序算法基于节点的入度，从入度为 0 的节点开始，依次将该节点从图中删除，并将其邻居节点的入度减 1，直至图中所有节点都被删除。 5. 强连通分量算法：用于有向图中，将图分割为强连通分量。强连通分量算法基于深度优先搜索，首先识别出图中的强连通分量，然后将每个强连通分量缩成一个节点，形成一个 DAG。 以上是图的基本运算算法，它们在图的各种应用场景中都有着重要的作用。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值