2、利用深度遍历或宽度遍历算法进行改造，编写函数实现求无向图的连通分量个数。 int Count(LGraph *g) { }

可以使用深度优先搜索（DFS）算法或广度优先搜索（BFS）算法来实现无向图的连通分量个数的计算。下面分别介绍这两种算法的实现方法。

1. 深度优先搜索算法实现

void DFS(LGraph *g, int v, bool visited[]) {
    visited[v] = true;  // 标记当前顶点已被访问
    ENode *p = g->a[v];  // 获取当前顶点的邻接表头结点
    while (p != NULL) {
        int w = p->adjVex;  // 获取当前邻接点的编号
        if (!visited[w]) {
            DFS(g, w, visited);  // 递归访问当前邻接点
        }
        p = p->nextarc;  // 访问下一个邻接点
    }
}

int Count(LGraph *g) {
    bool visited[g->n];  // 定义一个bool类型的visited数组，标记每个顶点是否被访问过
    int count = 0;  // 记录连通分量个数
    for (int i = 0; i < g->n; i++) {
        visited[i] = false;  // 初始化visited数组
    }
    for (int i = 0; i < g->n; i++) {
        if (!visited[i]) {
            DFS(g, i, visited);  // 对未访问的顶点进行DFS遍历
            count++;  // 每次遍历完成后，连通分量个数加1
        }
    }
    return count;
}

首先定义一个bool类型的visited数组，用于标记每个顶点是否被访问过。然后遍历每个顶点，对未访问过的顶点进行DFS遍历，每次遍历完成后，连通分量个数加1，最终返回连通分量个数。

2. 广度优先搜索算法实现

void BFS(LGraph *g, int v, bool visited[]) {
    visited[v] = true;  // 标记当前顶点已被访问
    queue<int> q;  // 定义一个队列，用于存储待访问的顶点
    q.push(v);  // 将当前顶点入队
    while (!q.empty()) {
        int u = q.front();  // 获取队首元素
        q.pop();  // 弹出队首元素
        ENode *p = g->a[u];  // 获取当前顶点的邻接表头结点
        while (p != NULL) {
            int w = p->adjVex;  // 获取当前邻接点的编号
            if (!visited[w]) {
                visited[w] = true;  // 标记当前邻接点已被访问
                q.push(w);  // 将当前邻接点入队
            }
            p = p->nextarc;  // 访问下一个邻接点
        }
    }
}

int Count(LGraph *g) {
    bool visited[g->n];  // 定义一个bool类型的visited数组，标记每个顶点是否被访问过
    int count = 0;  // 记录连通分量个数
    for (int i = 0; i < g->n; i++) {
        visited[i] = false;  // 初始化visited数组
    }
    for (int i = 0; i < g->n; i++) {
        if (!visited[i]) {
            BFS(g, i, visited);  // 对未访问的顶点进行BFS遍历
            count++;  // 每次遍历完成后，连通分量个数加1
        }
    }
    return count;
}

与DFS算法实现类似，这里使用一个bool类型的visited数组来标记每个顶点是否被访问过，然后使用队列存储待访问的顶点，对未访问过的顶点进行BFS遍历，每次遍历完成后，连通分量个数加1，最终返回连通分量个数。