輸出無向圖的鄰接表

阿新 • • 發佈：2018-12-08

https://blog.csdn.net/dwenxue/article/details/72831234

/*無向圖的鄰接表表示法*/
#include <iostream>
#include<stdio.h>
#include <string.h>
#define vnum 10

typedef struct arcnode
{
    int adjvex;                         /*下一條邊的頂點編號*/
    struct arcnode * nextarc;           /*指向下一條邊的指標*/
}ArcNode;
typedef struct vexnode
{
    int vertex;                         /*頂點編號*/
    ArcNode *firstarc;                  /*指向第一條邊的指標*/
}AdjList[vnum];
typedef struct gp
{
    AdjList adjlist;
    int vexnum,arcnum;                  /*頂點和邊的個數*/
}Graph;
void CreateAdjlist(Graph *g,int x,int y)     /*建立並初始化鄰接表*/
{
    int i;
    g->vexnum=x;
    g->arcnum=y;
    for(i=0;i<g->vexnum;i++)
    {
        g->adjlist[i].vertex=i;         /*初始化頂點資訊*/
        g->adjlist[i].firstarc=NULL;    /*初始化i的第一個鄰接點為NULL*/
    }
}
void InsertEdge(Graph *g)                    /*插入邊*/
{
    ArcNode *p;
    int i,j,k;
    for(k=0;k<g->arcnum;k++)
    {
        printf("輸入第%d條邊:",k+1);
        scanf("%d %d",&i,&j);
        p=(ArcNode *)malloc(sizeof(ArcNode));/*生成j的表結點*/
        p->adjvex=j;
        p->nextarc=g->adjlist[i].firstarc;   /*將結點j連結到i的單鏈表中*/
        g->adjlist[i].firstarc=p;
        p=(ArcNode *)malloc(sizeof(ArcNode));/*生成i的表結點*/
        p->adjvex=i;
        p->nextarc=g->adjlist[j].firstarc;   /*將結點i連結到j的單鏈表中*/
        g->adjlist[j].firstarc=p;
    }
}
void OutGraph(Graph *g)                      /*輸出鄰接表*/
{

 //   enum V{a,b,c,d, e, f, w,h }M[9];
    char M[10] = {'0', 'a','b','c','d', 'e', 'f', 'w', 'h' };

    int i;

    for(i=0;i<g->vexnum;i++)
    {
        printf("[%d]:    V%d",i, i+1);
        while(g->adjlist[i].firstarc!=0)
        {
            printf("---->%c ",M[g->adjlist[i].firstarc->adjvex]);
            g->adjlist[i].firstarc=g->adjlist[i].firstarc->nextarc;
        }
        printf("^\n");
    }
}
int main()
{
    Graph g;
    int x,y;
    printf("輸入頂點和邊的個數:\n");
    scanf("%d %d",&x,&y);
    CreateAdjlist(&g,x,y);
    InsertEdge(&g);
    OutGraph(&g);
}//1 2 1 3 2 3 2 4 2 5 3 4 3 8 4 5 4 6 4 7 4 8 5 6 6 7 7 8

//錯誤結果....

[0]: V1^
[1]: V2---->c ---->b ^
[2]: V3---->e ---->d ---->c ---->a ^
[3]: V4---->h ---->d ---->b ---->a ^
[4]: V5---->h ---->g ---->f ---->e ---->c ---->b ^
[5]: V6---->f ---->d ---->b ^
[6]: V7---->g ---->e ---->d ^
[7]: V8---->h ---->f ---->d ^

//以下是正確的...至於為什麼.....因為g->adjlist[0].firstarc在插入完成後變為了0......至於為什麼，目前還不明白.....

/*無向圖的鄰接表表示法*/
#include <iostream>
#include<stdio.h>
#include <string.h>
#define vnum 10

typedef struct arcnode
{
    int adjvex;                         /*下一條邊的頂點編號*/
    struct arcnode * nextarc;           /*指向下一條邊的指標*/
}ArcNode;
typedef struct vexnode
{
    int vertex;                         /*頂點編號*/
    ArcNode *firstarc;                  /*指向第一條邊的指標*/
}AdjList[vnum];
typedef struct gp
{
    AdjList adjlist;
    int vexnum,arcnum;                  /*頂點和邊的個數*/
}Graph;
void CreateAdjlist(Graph *g,int x,int y)     /*建立並初始化鄰接表*/
{
    int i;
    g->vexnum=x;
    g->arcnum=y;
    for(i=1;i<=g->vexnum;i++)
    {
        g->adjlist[i].vertex=i;         /*初始化頂點資訊*/
        g->adjlist[i].firstarc=NULL;    /*初始化i的第一個鄰接點為NULL*/
    }
}
void InsertEdge(Graph *g)                    /*插入邊*/
{
    ArcNode *p;
    int i,j,k;
    for(k=0;k<g->arcnum;k++)
    {
        printf("輸入第%d條邊:",k+1);
        scanf("%d %d",&i,&j);
        p=(ArcNode *)malloc(sizeof(ArcNode));/*生成j的表結點*/
        p->adjvex=j;
        p->nextarc=g->adjlist[i].firstarc;   /*將結點j連結到i的單鏈表中*/
        g->adjlist[i].firstarc=p;
        p=(ArcNode *)malloc(sizeof(ArcNode));/*生成i的表結點*/
        p->adjvex=i;
        p->nextarc=g->adjlist[j].firstarc;   /*將結點i連結到j的單鏈表中*/
        g->adjlist[j].firstarc=p;
    }
}
void OutGraph(Graph *g)                      /*輸出鄰接表*/
{

 //   enum V{a,b,c,d, e, f, w,h }M[9];
    char M[10] = {'0', 'a','b','c','d', 'e', 'f', 'w', 'h' };

    int i;

    for(i=1;i<=g->vexnum;i++)
    {
        printf("[%d]:    V%d",i-1, i);
        while(g->adjlist[i].firstarc!=0)
        {
            printf("---->%c ",M[g->adjlist[i].firstarc->adjvex]);
            g->adjlist[i].firstarc=g->adjlist[i].firstarc->nextarc;
        }
        printf("^\n");
    }
}
int main()
{
    Graph g;
    int x,y;
    printf("輸入頂點和邊的個數:\n");
    scanf("%d %d",&x,&y);
    CreateAdjlist(&g,x,y);
    InsertEdge(&g);
    OutGraph(&g);
}//1 2 1 3 2 3 2 4 2 5 3 4 3 8 4 5 4 6 4 7 4 8 5 6 6 7 7 8

/*
 *
[0]:    V1---->c ---->b ^
[1]:    V2---->e ---->d ---->c ---->a ^
[2]:    V3---->h ---->d ---->b ---->a ^
[3]:    V4---->h ---->w ---->f ---->e ---->c ---->b ^
[4]:    V5---->f ---->d ---->b ^
[5]:    V6---->w ---->e ---->d ^
[6]:    V7---->h ---->f ---->d ^
[7]:    V8---->w ---->d ---->c ^

 */

//除錯過程

/*無向圖的鄰接表表示法*/
#include <iostream>
#include<stdio.h>
#include <string.h>
#define vnum 10

typedef struct arcnode
{
    int adjvex;                         /*下一條邊的頂點編號*/
    struct arcnode * nextarc;           /*指向下一條邊的指標*/
}ArcNode;
typedef struct vexnode
{
    int vertex;                         /*頂點編號*/
    ArcNode *firstarc;                  /*指向第一條邊的指標*/
}AdjList[vnum];
typedef struct gp
{
    AdjList adjlist;
    int vexnum,arcnum;                  /*頂點和邊的個數*/
}Graph;
void CreateAdjlist(Graph *g,int x,int y)     /*建立並初始化鄰接表*/
{
    int i;
    g->vexnum=x;
    g->arcnum=y;
    for(i=0;i<g->vexnum;i++)
    {
        g->adjlist[i].vertex=i;         /*初始化頂點資訊*/
        g->adjlist[i].firstarc=NULL;    /*初始化i的第一個鄰接點為NULL*/
    }
}
void InsertEdge(Graph *g)                    /*插入邊*/
{
    ArcNode *p;
    int i,j,k;
    for(k=1;k<=g->arcnum;k++)
    {
        printf("輸入第%d條邊:",k+1);
        scanf("%d %d",&i,&j);
        p=(ArcNode *)malloc(sizeof(ArcNode));/*生成j的表結點*/
        p->adjvex=j;
        p->nextarc=g->adjlist[i].firstarc;   /*將結點j連結到i的單鏈表中*/
        g->adjlist[i].firstarc=p;
        p=(ArcNode *)malloc(sizeof(ArcNode));/*生成i的表結點*/
        p->adjvex=i;
        p->nextarc=g->adjlist[j].firstarc;   /*將結點i連結到j的單鏈表中*/
        g->adjlist[j].firstarc=p;
        printf("%d\n", g->adjlist[j].firstarc);
    }
}
void OutGraph(Graph *g)                      /*輸出鄰接表*/
{

    //   enum V{a,b,c,d, e, f, w,h }M[9];
    char M[10] = {'0', 'a','b','c','d', 'e', 'f', 'w', 'h' };

    int i;
    for(i=0;i<=g->vexnum;i++)
        printf("%d\n", g->adjlist[i].firstarc);

    for(i=1;i<=g->vexnum;i++)
    {
        printf("[%d]:    V%d %d",i, i+1, g->adjlist[i].firstarc);

        while(g->adjlist[i].firstarc!=0)
        {
            printf("---->%c ",M[g->adjlist[i].firstarc->adjvex]);
            g->adjlist[i].firstarc=g->adjlist[i].firstarc->nextarc;
        }
        printf("^\n");
    }
}
int main()
{
    Graph g;
    int x,y;
    printf("輸入頂點和邊的個數:\n");
    scanf("%d %d",&x,&y);
    CreateAdjlist(&g,x,y);
    InsertEdge(&g);
    OutGraph(&g);
}//1 2 1 3 2 3 2 4 2 5 3 4 3 8 4 5 4 6 4 7 4 8 5 6 6 7 7 8
/*
 * 輸入第1條邊:1 2 1 3 2 3 2 4 2 5 3 4 3 8 4 5 4 6 4 7 4 8 5 6 6 7 7 8
75920
輸入第2條邊:75984
輸入第3條邊:436608
輸入第4條邊:436672
輸入第5條邊:436736
輸入第6條邊:436800
輸入第7條邊:436864
輸入第8條邊:436928
輸入第9條邊:436992
輸入第10條邊:437056
輸入第11條邊:437120
輸入第12條邊:437184
輸入第13條邊:437248
輸入第14條邊:437312
0
75952
436704
436832
437088
437152
437216
437280
[0]:    V1 0^
[1]:    V2 75952---->c ---->b ^
[2]:    V3 436704---->e ---->d ---->c ---->a ^
[3]:    V4 436832---->h ---->d ---->b ---->a ^
[4]:    V5 437088---->h ---->w ---->f ---->e ---->c ---->b ^
[5]:    V6 437152---->f ---->d ---->b ^
[6]:    V7 437216---->w ---->e ---->d ^
[7]:    V8 437280---->h ---->f ---->d ^

 */

/*
 * 輸入頂點和邊的個數:
8 14
輸入第2條邊:1 2 1 3 2 3 2 4 2 5 3 4 3 8 4 5 4 6 4 7 4 8 5 6 6 7 7 8
75920
輸入第3條邊:75984
輸入第4條邊:436608
輸入第5條邊:436672
輸入第6條邊:436736
輸入第7條邊:436800
輸入第8條邊:436864
輸入第9條邊:436928
輸入第10條邊:436992
輸入第11條邊:437056
輸入第12條邊:437120
輸入第13條邊:437184
輸入第14條邊:437248
輸入第15條邊:437312
0
75952
436704
436832
437088
437152
437216
437280
437312
[1]:    V2 75952---->c ---->b ^
[2]:    V3 436704---->e ---->d ---->c ---->a ^
[3]:    V4 436832---->h ---->d ---->b ---->a ^
[4]:    V5 437088---->h ---->w ---->f ---->e ---->c ---->b ^
[5]:    V6 437152---->f ---->d ---->b ^
[6]:    V7 437216---->w ---->e ---->d ^
[7]:    V8 437280---->h ---->f ---->d ^
[8]:    V9 437312---->w ---->d ---->c ---->0 ^

Process finished with exit code 0

 */

12.boost有向無向圖鄰接表表示

blog 所有結點 ace 都是 col vector fin std pan 1 #include <iostream> 2 #include <boost/config.hpp> 3 //圖(矩陣實現) 4 #include <b

Java實現無向圖鄰接表

這個實現只考慮實現無向圖鄰接表的功能，底層使用HashMap。提供瞭如下的API： 1. addEdge，新增一條邊 2. removeEdge，刪除某條邊 3. containsEdge，是否包含某條邊 4. show，列印展示整個圖 5. edgeNum，返回邊的數目

無向圖-鄰接表js實現

鄰接表，儲存方法跟樹的孩子連結串列示法相類似，是一種順序分配和鏈式分配相結合的儲存結構。如這個表頭結點所對應的頂點存在相鄰頂點，則把相鄰頂點依次存放於表頭結點所指向的單向連結串列中。對於無向圖來說，使用鄰接表進行儲存也會出現資料冗餘，表頭結點A所指連結串列中存在一個指向C

輸出無向圖的鄰接表

https://blog.csdn.net/dwenxue/article/details/72831234 /*無向圖的鄰接表表示法*/ #include <iostream> #include<stdio.h> #include <string

資料結構與演算法——有向圖鄰接表輸出其拓撲排序序列

測試資料輸入： 12 16 c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c1 c4 c1 c2 c1 c3 c1 c12 c4 c5 c2 c3 c3 c5 c3 c7 c5 c7 c3 c8 c9 c12 c9 c10 c10 c12 c

實驗四（建圖，無向圖+鄰接矩陣（BFS，DFS（遞迴+非遞迴）），有向圖+鄰接表（BFS，DFS（遞迴+非遞迴）），拓撲排序）

//Sinhaeng Hhjian #include<bits/stdc++.h> using namespace std; const int N=100; const int MAX=1000; int book[N], cnt; struct node{

有向圖和無向圖鄰接矩陣的輸入輸出，深度深度優先搜尋，廣度優先搜尋

#include<iostream> #include<stdlib.h> #include<malloc.h> #include<queue> #define MAXLEN 100 using namespace std; t

無向圖鄰接連結串列的廣度優先搜尋

個人認為圖的演算法看起來非常簡潔，但是實現起來需要基礎很紮實。因為經常會涉及多種簡單的資料結構，怎樣把他們恰當的串聯起來，不會報那種，空指標了，型別不匹配，實體型別不符合了等等。在做無向圖鄰接連結串列廣度優先搜尋的時候，寫的很冒火，想去找別的博主的程式碼借鑑一下，發現大部分，真的是大部分，

leetcode 207 課程表有向圖鄰接表判斷是否有環

class Solution { struct GraphNode{ int label; vector<GraphNode*>neighbors; GraphNode(int x):label(x) {};

無向圖-鄰接矩陣-寬度優先遍歷-BFS C程式碼實現

一、BFS演算法思路本演算法以無向圖為例，儲存方式採用鄰接矩陣1）將該網以鄰接矩陣的方式儲存，由於這裡的示例採用無向圖，因此它是一個對稱陣2）選取A點為起始點，訪問此頂點，用一個visit的bool型陣列記錄訪問狀態（false表示未被訪問，true表示已訪問）3）從A的未被

Prim輸出無向圖中所有的最小生成樹

思路：給出n個頂點m條邊。一棵最小生成樹中有n-1條邊，所以在m條邊中選n-1條邊判斷能否構成最小生成樹，如果能則直接輸出。判斷是否能構成最小生成樹的條件是當前的n-1條邊的權值的和是否是最小生成樹的權值的和(程式碼裡的ans)。步驟：先進行一

有向圖鄰接表求入度，出度，刪除、增加頂點，弧，深度遍歷及其生成樹等

#include "stdio.h"#include "math.h"#include"malloc.h"#include "stack"#include <queue>#define OK 1#define ERROR -1#define MAX 32764 /

無向圖-鄰接連結串列的深度優先遍歷-DFS

一、DFS思想本演算法以無向網為例，儲存方式採用鄰接連結串列1）將該網以鄰接連結串列的方式儲存2）選取A點為起始點，訪問此頂點，用一個visit的bool型陣列記錄訪問狀態（false表示未被訪問，true表示已訪問）3）從A的未被訪問的鄰接點出發，深度優先遍歷圖，直到圖中所

有向圖---鄰接表（BFS+DFS）

#include <stdio.h> #include <malloc.h> #define true 1 #define false 0 #define INFINITY 1000000 #define MaxVertexNum 100 #

演算法與資料結構基礎8：C++實現有向圖——鄰接表儲存

前面實現了連結串列和樹，現在看看圖。連結串列是一對一的對應關係；樹是一對多的對應關係；圖是多對多的對應關係。圖一般有兩種儲存方式，鄰接表和鄰接矩陣。先看鄰接表。鄰接表就是將圖中所有的點用一個數組儲存起來，並將此作為一個連結串列的頭，連結串列中儲存跟這個點相鄰的

用鄰接表實現無向圖的建立與輸出

1 #include<stdio.h> 2 #include <iostream> 3 #include<algorithm> 4 using namespace std; 5 #define MVNum 100 6 typedef struct ArcN

鄰接表建立無向圖，深度優先搜尋遍歷輸出

1 #include<stdio.h> 2 #include<string.h> 3 #include <iostream> 4 #include<algorithm> 5 using namespace std; 6 #define MVNu

鄰接表創建無向圖，廣度優先搜索遍歷輸出

ron code fir 是否廣度優先搜索遍歷 new vnode 分配 std 1 #include<stdio.h> 2 #include<string.h> 3 #include <iostream> 4 #in

鄰接表建立無向圖，廣度優先搜尋遍歷輸出

1 #include<stdio.h> 2 #include<string.h> 3 #include <iostream> 4 #include<algorithm> 5 using namespace std; 6 #defin

無向圖的鄰接表結構

public class LinkUDG { private class Enode{//邊表 int pos;//儲存某頂點的鄰接點在頂點表中的下標 Enode nextNode;//指向下一個節點 } private

輸出無向圖的鄰接表

相關推薦