邻接表

ACM模版

邻接表(网)

图描述:结点带权值,边带权值,有向图,属于网结构。

using namespace std;

//  边点结构
typedef struct Edge
{
    int tag;
    int weigh;
    struct Edge *next;
}Edge;

//  表结构
typedef struct Table
{
    int data;
    Edge *first;
}Table, *Tables;

int main(int argc, const char * argv[])
{
    int N, M;
    while (cin >> N >> M)   //  N结点数、M路径数
    {
        Tables table = (Tables)malloc(sizeof(Table) * N);
        int data, start, end, weigh;

        //  初始化结点
        for (int i = 0; i < N; i++)
        {
            cin >> data;
            table[i].data = data;
            table[i].first = NULL;
        }

        //  添加路径
        for (int i = 0; i < M; i++)
        {
            cin >> start >> end >> weigh;
            Edge *NN = (Edge *)malloc(sizeof(Edge));
            if (NULL == table[start].first)
            {
                table[start].first = NN;
                NN->tag = end;
                NN->weigh = weigh;
                NN->next = NULL;
            }
            else
            {
                NN = table[start].first;
                while (NULL != NN->next)
                {
                    NN = NN->next;
                }
                Edge *MM = (Edge *)malloc(sizeof(Edge));
                MM->tag = end;
                MM->weigh = weigh;
                MM->next = NULL;
                NN->next = MM;
            }
        }

        //  打印邻接表
        for (int i = 0; i < N; i++)
        {
            cout << i << ":" << table[i].data << "   ";         //  结点下标:结点权值
            if (table[i].first == NULL)
            {
                cout << "OVER" << endl;
                continue;
            }
            Edge *NN = (Edge *)malloc(sizeof(Edge));
            NN = table[i].first;
            cout << NN->tag << ":" << NN->weigh << "   ";       //  路径终点:路径权值
            while (NN->next != NULL)
            {
                NN = NN->next;
                cout << NN->tag << ":" << NN->weigh << "   ";   //  路径终点:路径权值
            }
            cout << "OVER" << endl;
        }
    }

    return 0;
}
### 图的邻接链表表示方法及实现示例 #### 邻接链表的基本概念 邻接链表是一种用于表示图的数据结构,特别适用于稀疏图(即边的数量远小于顶点数量平方的图)。其核心思想是,对于图中的每个顶点,使用一个链表来存储与该顶点相邻的其他顶点。每个链表中的节点表示从当前顶点出发的边的终点。这种方式能够高效地存储和遍历图的边,同时节省存储空间[^1]。 在有向图中,邻接链表仅记录从当前顶点出发的边的终点。例如,如果存在一条从顶点 A 到顶点 B 的边,则在顶点 A 的邻接链表中添加 B,但在顶点 B 的邻接链表中不会添加 A。 #### 邻接链表的实现 下面是一个使用 C++ 实现有向图的邻接链表表示的示例。该实现包括以下几个组件: - `Graph`:表示整个有向图。 - `Node`:表示图中的一个顶点及其邻接链表。 - `AdjNode`:表示邻接链表中的一个节点。 ```cpp #include <iostream> using namespace std; // 邻接表中的节点 struct AdjNode { int dest; // 边的终点 AdjNode* next; // 指向下一个邻接节点的指针 AdjNode(int dest) : dest(dest), next(nullptr) {} }; // 图的节点 struct Node { AdjNode* head; // 指向邻接表的头节点 Node() : head(nullptr) {} }; // 图的邻接表表示 class Graph { private: int numVertices; // 图中的顶点数量 Node* adjListArray; // 邻接表数组 public: // 构造函数 Graph(int numVertices) { this->numVertices = numVertices; adjListArray = new Node[numVertices]; } // 添加边 void addEdge(int src, int dest) { // 创建新的邻接节点 AdjNode* newNode = new AdjNode(dest); newNode->next = adjListArray[src].head; adjListArray[src].head = newNode; } // 打印图的邻接表表示 void printGraph() { for (int i = 0; i < numVertices; ++i) { cout << "顶点 " << i << " 的邻接表: "; AdjNode* temp = adjListArray[i].head; while (temp) { cout << "-> " << temp->dest; temp = temp->next; } cout << endl; } } // 析构函数 ~Graph() { for (int i = 0; i < numVertices; ++i) { AdjNode* temp = adjListArray[i].head; while (temp) { AdjNode* next = temp->next; delete temp; temp = next; } } delete[] adjListArray; } }; int main() { Graph graph(5); // 创建一个包含5个顶点的图 graph.addEdge(0, 1); graph.addEdge(0, 4); graph.addEdge(1, 2); graph.addEdge(1, 3); graph.addEdge(1, 4); graph.addEdge(2, 3); graph.addEdge(3, 4); graph.printGraph(); return 0; } ``` #### 代码解析 1. **数据结构定义**: - `AdjNode` 结构体表示邻接表中的一个节点,包含边的终点和指向下一个节点的指针。 - `Node` 结构体表示图中的一个顶点,包含指向邻接表头节点的指针。 - `Graph` 类表示整个有向图,包含顶点数量和邻接表数组。 2. **添加边**: - `addEdge` 方法用于在图中添加一条从 `src` 到 `dest` 的边。该方法创建一个新的 `AdjNode` 节点,并将其插入到 `src` 的邻接表链表中。 3. **打印图的邻接表表示**: - `printGraph` 方法遍历图的每个顶点,并打印其邻接表中的所有节点。 4. **内存管理**: - 析构函数 `~Graph` 负责释放图中所有邻接表节点占用的内存,避免内存泄漏。 #### 邻接链表的优势 - **空间效率**:邻接链表在存储稀疏图时比邻接矩阵更节省空间,因为它仅存储存在的边。 - **灵活性**:邻接链表能够轻松处理动态变化的图,例如频繁添加或删除边的情况。 - **遍历效率**:对于图的遍历操作(如深度优先搜索和广度优先搜索),邻接链表通常比邻接矩阵更高效,因为它直接提供了每个顶点的所有邻接节点。 #### 应用场景 邻接链表广泛应用于图算法中,例如: - **最短路径算法**:如 Dijkstra 算法和 Bellman-Ford 算法。 - **最小生成树算法**:如 Prim 算法。 - **拓扑排序**:用于有向无环图的排序。 - **网络流算法**:如 Ford-Fulkerson 算法。 #### 相关问题 1. 邻接矩阵和邻接链表在表示图时的优缺点是什么? 2. 如何在邻接链表中实现图的深度优先搜索? 3. 如何在邻接链表中实现图的广度优先搜索? 4. 如何在邻接链表中添加带权重的边? 5. 如何在邻接链表中删除一条边?
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值