邻接表

度：无向图的度：顶点与邻接点连接的边就做度。有向图的度：指向顶点的边叫做入度，由顶点指向其他邻接点的边叫做出度

顶点：存储自身顶点信息和指向下一个临界点的指针

邻接点：保存临接点的存储下标和下一个邻接点的指向指针

存储方式：单向链接

无向图存储

arr[] = {a, d, c, b}  0 1 2 3

一个节点可以能多个邻接点，该节点可通过索引进行选择下一个邻接点选择哪个，如下图：

头表和邻接表

由上图可知，A有三个邻接点，分别是B C D。B有两个邻接点，分别是A C

在需要时，A可以直接指向C或D

有向图存储

有向图中，每一条边都有方向指向，分为出边和入边

在邻接表存储中只有出边没有入边

如上，只有A到E的边，没有E到A的边

带权图，只需同上加一个 权值表即可

在实际存储过程中，顶点和邻接点常以两种形式存储

邻接点：

struct AjdNode

{

    int index; 下标

    struct AdjNode* next; 指向下一个同类型的指针

}

顶点：

struct Node

{

    int data； 任意类型的数据域

    struct AjdNode* first;  指向第一个邻接点结构的指针

}

邻接表代码实现

const int g_maxcount = 1000;  定义一个最大节点数

int g_edge;

int g_nCount;

typedef struct _Node  按常理应有顶点和邻接点结构体，但此处省略写，两者共用一个结构体

{

    int nIndex;  既是邻接点下标也是data

    struct _Node * next;

}Node;

Node* head[g_nMaxCount]; 

声明一个数组，head相当于顶点，[]中相当于下标指向某一个顶点

void Create() 创建

{

    std::cout << "Input Node Count And Edge:" ;

    char cStart;  

    char cEnd; 边的两头，两个节点的字符

    std::cin >> g_nCount >> g_Edge; 输入要有多少个节点多少个边

    for(size_t i = 0; i < g_nEdge; i++)

    {

        std::cin >> cStart >> cEnd; 输入边的两头 如边ab ac

        int headIndex = cStart - 'a'; 转成数字编号，头节点的下标

        int nEdgeIndex = cEnd - 'a'; 尾节点的下标 input a - a = 0, b - a = 1 ,ASCII码应用

        Node* newNode = new Node; 进行插入

        newNode->nIndex = nEdgeIndex; 

        比如head是a edge是b，输入ab，a是顶点，b是邻接点，以邻接点b即b-a的数值当作下标从a指向b，具体理解如下

        newNode->next = head[nheadIndex];头插法，将新节点向下的指针，指向原有的第一个邻接点

        head[nheadIndex] = newNode;

    }

}

void print() 输出

{

    for(size_t i = 0; i < g_nCount; i++) 判断有多少个头

    {

        for(Node* temp = head[i]; temp != NULL; temp = temp->next) 遍历所有的头的邻接点

        临时节点指向头节点

        {

            std::out << "[" <<temp->nIndex << "]\t";

        }

        std::cout << std::endl;

    }

}

链式前向星

链式前向星由边集数组和头顶点数组组成，优点是可以快速访问一个点所有邻接点

边集数组 egde[i]  存储边

#define max 100

struct node  边集数组结构

{

    int to; 结尾的点

    struct node * next;

    int weight; 权值

}edge[max]; 定义有100个结构体

如下一个无向图

头节点数组

head[i] 存储下标 指向的第一个edge的下标

该图存储各个顶点信息 -1表示该顶点没有连向任何一个节点

边集数组便是将上述两个图结合起来，具体如下

最左边一列表示以哪个节点作为顶点

head表示该顶点指向的第一个边，如上图第一行head为2表示A指向了第2个边即edge[2]

上图中存储了各个边的信息 如第一条边存储了AB边，B是1，to是1

如上图边集数组A指向C之后A指向B，则在上图AC边next指向AB边

链式前向星代码实现

const int g_MaxCount = 100;

int g_nCount;  节点

int g_nEdge;  边

int g_nIndex;  索引

int g_nTo;  尾节点

int g_nWeight; 权值

int g_nHead; 顶点

int head[g_MaxCount]; 

struct Edge 边集数组

{

    int to;

    int weight;

    int next;

}e[g_MaxCount];

void init()

{

    memset(head, -1, (sizeof(int) * g_MaxCount));

    g_nHead = 0;

}

void add（int index; int to; int weight)

{

    e[g_nHead].to = to;

    e[g_nHead].weight = weight;

    e[g_Head].next = head[index];

    head[index] = g_nHead++; 

}

void print()

{

    for(size_t i = 1; i <= g_nCount; i++)

    {

        std::cout << i << ":\t";

        for(size_t j = head[i]; ~j; j = e[j].next) 遍历头数组 ~j相当于j != -1

        {

            std::cout << "[" << e[i].to << e[i].weight << "]\t";

        }

        std::cout << std::endl;

    }

}

应用：

std::cin >> g_nCount >> g_nEdge;

init();

for(size_t i = 1; i <= g_nEdge; i++)

{

    std::cin >> g_nIndex >> g_nTo >> g_nWeight;

    add(g_nIndex, g_nTo, g_nWeigh);

    add(g_nTo, g_nIndex, g_nWeigh);

}

print();

应用结果如下图