采用邻接表创建无向图g ，依次输出各顶点的度。

### 回答1：
首先，邻接表是一种表示图的数据结构，它由一个数组和若干个链表组成。数组中的每个元素表示一个顶点，链表中存储该顶点所连接的其他顶点。

创建无向图g的邻接表可以按照以下步骤进行：

1. 定义一个包含n个链表的数组，其中n为图中顶点的个数。

2. 对于每个顶点，创建一个链表，用于存储与该顶点相邻的其他顶点。

3. 遍历图中的每条边，将每个顶点所连接的其他顶点添加到对应的链表中。

4. 输出各顶点的度，即为该顶点所连接的其他顶点的个数。

具体实现可以参考以下代码：

#include <iostream>
#include <vector>

using namespace std;

// 定义邻接表节点
struct Node {
    int val;
    Node* next;
    Node(int v) : val(v), next(nullptr) {}
};

// 定义邻接表
class Graph {
public:
    Graph(int n) : nodes(n), edges() {
        for (int i = ; i < n; i++) {
            nodes[i] = new Node(i);
        }
    }

    // 添加边
    void addEdge(int u, int v) {
        Node* node1 = new Node(v);
        node1->next = nodes[u]->next;
        nodes[u]->next = node1;

        Node* node2 = new Node(u);
        node2->next = nodes[v]->next;
        nodes[v]->next = node2;

        edges++;
    }

    // 输出各顶点的度
    void printDegrees() {
        for (int i = ; i < nodes.size(); i++) {
            int degree = ;
            Node* cur = nodes[i]->next;
            while (cur) {
                degree++;
                cur = cur->next;
            }
            cout << "顶点" << i << "的度为：" << degree << endl;
        }
    }

private:
    vector<Node*> nodes; // 邻接表数组
    int edges; // 边数
};

int main() {
    int n = 5; // 顶点个数
    Graph g(n);

    // 添加边
    g.addEdge(, 1);
    g.addEdge(, 2);
    g.addEdge(1, 2);
    g.addEdge(1, 3);
    g.addEdge(2, 3);
    g.addEdge(3, 4);

    // 输出各顶点的度
    g.printDegrees();

    return ;
}

输出结果为：

顶点的度为：2
顶点1的度为：3
顶点2的度为：3
顶点3的度为：3
顶点4的度为：1

### 回答2：
无向图是一种不具有方向性的图形，其由若干个顶点和若干条无序的边构成。在无向图中，每个顶点有若干个相邻的顶点，而每一条边连接的两个顶点的度数均为1。因此，我们可以采用邻接表的方式来创建无向图g，依次输出各顶点的度数。

首先，我们需要了解邻接表的定义和构成。邻接表是一种用于表示图的数据结构，它由一个顶点数组和一个边链表组成。其中，顶点数组记录了所有图的顶点信息，而边链表则记录了每个顶点所相邻的所有顶点。

在将无向图g转化为邻接表表示时，我们需要对每个顶点建立一个链表，链表中列出该顶点所相邻的所有顶点。具体的实现过程如下：

1. 创建一个顶点数组，数组的大小为无向图g的顶点数。每个数组元素都包括两个字段：一个是顶点编号，另一个是该顶点所相邻的顶点链表的头结点。
2. 对于每条在g中的边(u,v)，将v加入u的相邻链表中，同时将u加入v的相邻链表中。
3. 遍历顶点数组，计算每个顶点的度数。由于g为无向图，因此每个顶点的度数等于其相邻链表中元素的个数。

以一个简单的5个顶点的无向图为例，其邻接表创建过程如下：

class Graph:
    def __init__(self, n):
        self.nodes = []
        self.n = n
        for i in range(n):
            self.nodes.append(Node(i, None))
    
    def add_edge(self, u, v):
        node_u = self.nodes[u]
        node_v = self.nodes[v]
        while node_u.next:
            node_u = node_u.next
        while node_v.next:
            node_v = node_v.next
        node_u.next = Node(v, None)
        node_v.next = Node(u, None)
    
    def print_degree(self):
        for node in self.nodes:
            degree = 0
            cur = node.next
            while cur:
                degree += 1
                cur = cur.next
            print(node.val, degree)
        
class Node:
    def __init__(self, val, next):
        self.val = val
        self.next = next

# 测试代码
g = Graph(5)
g.add_edge(0, 1)
g.add_edge(0, 2)
g.add_edge(0, 4)
g.add_edge(1, 3)
g.add_edge(1, 4)
g.print_degree() # 输出每个顶点的度

在上述代码中，我们首先创建了一个大小为5的顶点数组，并通过`add_edge`方法将边(u,v)加入顶点u和v的相邻链表中。最后，我们遍历整个顶点数组，计算每个顶点的度数，并将其输出。

以上就是利用邻接表来创建无向图g，并输出各顶点的度的过程，该方法具有时间复杂度O(m+n)，其中m为边数，n为顶点数。

### 回答3：
邻接表是用来存储图的一种数据结构，它由一个一维数组和多个链表组成，每个数组元素对应一个顶点，数组中存储的值是与该顶点相邻的顶点的链表头指针。邻接表适合用于表示稀疏图。

对于无向图g，我们可以采用邻接表来表示。首先，我们需要定义一个链表的结构体，包含两个成员：一个是顶点下标，另一个是指向下一个相邻顶点的指针。

struct node {
    int index;         // 顶点下标
    struct node* next; // 指向下一个相邻顶点的指针
};

然后，我们定义一个数组adjList，大小为顶点数，数组中的每个元素都是一个指向链表头的指针。表示与该顶点相邻的所有顶点。

struct node *adjList[MAX_VERTEX_NUM]; // 邻接表数组，大小为顶点数

接下来，通过读入每条边信息，我们可以更新邻接表的数据。具体来说，我们对于每条边(u, v)，都将v添加到u的链表中，将u添加到v的链表中。这里有一个需要注意的点：由于是无向图，我们需要在更新u的链表时，同时更新v的链表。因此，我们需要将v添加到u的链表中，同时将u添加到v的链表中。

struct node *p, *q;
p = (struct node *) malloc(sizeof(struct node));
p->index = v;  // 邻接点下标为v
p->next = adjList[u];  // 将p插入到u的链表头
adjList[u] = p;
q = (struct node *) malloc(sizeof(struct node));
q->index = u;  // 邻接点下标为u
q->next = adjList[v];  // 将q插入到v的链表头
adjList[v] = q;

有了邻接表，我们就可以方便地求出每个顶点的度了。对于顶点i的度，只需要计算其邻接表中链表的长度即可。

int degree[MAX_VERTEX_NUM];  // 存储各顶点的度
for (int i = 0; i < n; i++) {
    int cnt = 0;
    p = adjList[i];
    while (p != NULL) {
        cnt++;
        p = p->next;
    }
    degree[i] = cnt;
}

最终，我们可以依次输出各顶点的度。

for (int i = 0; i < n; i++)
    printf("顶点%d的度为%d\n", i, degree[i]);