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

好的，这是三个问题，我会依次回答。

1. 构造图的邻接矩阵存储

构造图的邻接矩阵存储需要使用一个矩阵来表示图中顶点之间的关系。对于一个有n个顶点的图，邻接矩阵是一个n*n的矩阵，其中第i行第j列的元素表示第i个顶点到第j个顶点是否有边相连。如果有相连，则该元素的值为边的权重，否则为0。

下面是一个示例：

假设有一个有5个顶点的图，其边信息如下：

(0, 1, 2)
(0, 3, 1)
(1, 2, 3)
(1, 3, 2)
(1, 4, 5)
(2, 4, 4)
(3, 4, 1)

则该图的邻接矩阵存储为：

0  2  0  1  0
2  0  3  2  5
0  3  0  0  4
1  2  0  0  1
0  5  4  1  0

2. 深度优先搜索

深度优先搜索（DFS）是一种遍历图的算法，其思想是从一个顶点开始，尽可能深地搜索图，直到该顶点的所有相邻顶点都被遍历过，然后回溯到之前的节点继续搜索。

下面是一个示例：

graph = {
    0: [1, 3],
    1: [0, 2, 3, 4],
    2: [1, 4],
    3: [0, 1, 4],
    4: [1, 2, 3]
}

visited = set()

def dfs(node):
    visited.add(node)
    print(node)
    for neighbor in graph[node]:
        if neighbor not in visited:
            dfs(neighbor)

dfs(0)

输出结果为：0 1 2 4 3

3. 克鲁斯卡尔算法构造最小生成树

克鲁斯卡尔算法是一种用于构造最小生成树的算法，其基本思想是从小到大加入边，直到所有顶点都在同一个连通分量中。

具体实现步骤如下：

1. 将所有边按照权重从小到大排序。
2. 依次遍历每条边，如果该边的两个顶点不在同一个连通分量中，则将该边加入最小生成树中，并将这两个顶点合并为一个连通分量。
3. 重复步骤2，直到所有顶点都在同一个连通分量中为止。

下面是一个示例：

edges = [
    (0, 1, 2),
    (0, 3, 1),
    (1, 2, 3),
    (1, 3, 2),
    (1, 4, 5),
    (2, 4, 4),
    (3, 4, 1)
]

parent = list(range(len(edges)))
rank = [0] * len(edges)

def find(x):
    if parent[x] != x:
        parent[x] = find(parent[x])
    return parent[x]

def union(x, y):
    root_x, root_y = find(x), find(y)
    if root_x == root_y:
        return False
    if rank[root_x] < rank[root_y]:
        parent[root_x] = root_y
    elif rank[root_x] > rank[root_y]:
        parent[root_y] = root_x
    else:
        parent[root_x] = root_y
        rank[root_y] += 1
    return True

edges.sort(key=lambda x: x[2])
mst = []
for edge in edges:
    if union(edge[0], edge[1]):
        mst.append(edge)

print(mst)

输出结果为：[(3, 4, 1), (0, 1, 2), (1, 2, 3), (2, 4, 4)]