（1）由给定的顶点和边的信息构造图的邻接矩阵存储； （2）对该图进行深度优先搜索，输出搜索得到的结点序列； （3）以邻接表作存储结构，用克鲁斯卡尔算法构造最小生成树。

好的，我明白了。让我们逐个回答您的问题。

(1) 由给定的顶点和边的信息构造图的邻接矩阵存储：

首先，我们需要定义一个邻接矩阵 $A$，它的大小为 $n\times n$，其中 $n$ 是图中顶点的数量。然后，我们需要根据给定的信息来填充邻接矩阵。

假设我们有 $m$ 条边，每条边连接两个顶点 $u$ 和 $v$，并且有一个权重 $w$。那么，我们可以使用以下代码来构建邻接矩阵：

// 假设我们已经定义好了图的大小 n 和边的数量 m
int A[n][n]; // 定义邻接矩阵

// 初始化邻接矩阵
for (int i = 0; i < n; i++) {
    for (int j = 0; j < n; j++) {
        A[i][j] = 0; // 默认没有边相连
    }
}

// 填充邻接矩阵
for (int k = 0; k < m; k++) {
    int u, v, w; // 从给定信息中获取边的信息
    A[u][v] = w;
    A[v][u] = w; // 无向图需要对称填充
}

这样，我们就成功地构造了一个邻接矩阵来表示给定的图。

(2) 对该图进行深度优先搜索，输出搜索得到的结点序列：

深度优先搜索算法（Depth First Search，DFS）是一种用于遍历或搜索树或图的算法。它从一条指定的边开始，然后尽可能地“深入”每个顶点，直到无法继续为止，然后回溯到该点的上一个顶点，并尝试访问另一个路径。使用深度优先搜索算法可以找到任意两个顶点之间的路径。

以下是使用深度优先搜索算法遍历给定图的基本步骤：

1. 初始化一个空的栈，将起始顶点压入栈中。
2. 从栈中弹出一个顶点，并将其标记为已访问。
3. 检查该顶点的邻居，如果邻居未被访问，则将其压入栈中。
4. 重复步骤 2 和步骤 3，直到栈为空。

以下是使用深度优先搜索算法遍历给定图并输出搜索顺序的代码：

// 假设我们已经定义好了图的邻接矩阵 A
bool visited[n]; // 定义一个数组来记录每个顶点是否已经被访问过

// 深度优先搜索函数
void dfs(int u) {
    visited[u] = true; // 标记该顶点已经被访问过
    cout << u << " "; // 输出该顶点

    // 检查该顶点的邻居
    for (int v = 0; v < n; v++) {
        if (A[u][v] != 0 && !visited[v]) {
            dfs(v); // 如果邻居未被访问，则递归访问它
        }
    }
}

// 遍历图的每个连通分量
void dfsTraversal() {
    // 初始化 visited 数组
    for (int i = 0; i < n; i++) {
        visited[i] = false;
    }

    // 遍历每个顶点
    for (int u = 0; u < n; u++) {
        if (!visited[u]) {
            dfs(u); // 如果该顶点未被访问，则从该顶点开始进行深度优先搜索
        }
    }
}

(3) 以邻接表作存储结构，用克鲁斯卡尔算法构造最小生成树：

克鲁斯卡尔算法（Kruskal Algorithm）是一种用于求解加权无向图的最小生成树的贪心算法。它的基本思想是从小到大依次选择每条边，如果该边不会与已选择的边形成环，就将其加入最小生成树中。

以下是使用邻接表作为存储结构，并使用克鲁斯卡尔算法构造最小生成树的代码：

// 假设我们已经定义好了图的顶点数量 n 和边的数量 m
vector<pair<int, pair<int, int>>> edges; // 定义边的信息（起点、终点、权重）
vector<int> parent(n); // 定义每个顶点的父节点，用于判断是否形成环

// 初始化 parent 数组
for (int i = 0; i < n; i++) {
    parent[i] = i;
}

// 克鲁斯卡尔算法
int kruskalMST() {
    int mstWeight = 0; // 最小生成树的权重

    // 按照权重从小到大对边进行排序
    sort(edges.begin(), edges.end());

    // 依次加入每条边
    for (auto edge : edges) {
        int u = edge.second.first;
        int v = edge.second.second;
        int w = edge.first;

        // 检查该边的两个顶点是否已经在同一集合中
        int parentU = findParent(u);
        int parentV = findParent(v);
        if (parentU != parentV) {
            // 如果不在同一集合中，则加入该边，并将两个集合合并
            mstWeight += w;
            parent[parentU] = parentV;
        }
    }

    return mstWeight;
}

// 查找该顶点所在集合的根节点
int findParent(int u) {
    while (parent[u] != u) {
        u = parent[u];
    }
    return u;
}

这样，我们就成功地使用了邻接表作为存储结构，并使用克鲁斯卡尔算法构造了给定图的最小生成树。