python数据结构

 用邻接矩阵表示法创建无向网

def create_adj_matrix(vexnum, arcnum, vertices, edges):
    # 初始化邻接矩阵，使用 '-1' 表示无穷大（无边）
    inf = -1
    adj_matrix = [[inf] * vexnum for _ in range(vexnum)]

    # 构建邻接矩阵，初始化对角线为0（自身到自身的边）
    for i in range(vexnum):
        adj_matrix[i][i] = 0

    # 填充邻接矩阵，根据边的信息（顶点1，顶点2，权值）
    for v1, v2, w in edges:
        i = vertices.index(v1)
        j = vertices.index(v2)
        adj_matrix[i][j] = w
        adj_matrix[j][i] = w  # 无向图对称填充

    return adj_matrix

def print_adj_matrix(matrix, vertices):
    print("  ", " ".join(vertices))
    for i, row in enumerate(matrix):
        print(vertices[i], " ".join(map(str, row)))

if __name__ == "__main__":
    # 读取输入
    vexnum = int(input())
    arcnum = int(input())
    vertices = input().split()
    edges = []

    for _ in range(arcnum):
        v1, v2, w = input().split()
        w = int(w)
        edges.append((v1, v2, w))

    # 创建邻接矩阵
    adj_matrix = create_adj_matrix(vexnum, arcnum, vertices, edges)

    # 输出邻接矩阵
    print_adj_matrix(adj_matrix, vertices)

由字符串创建先序二叉树 

class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right


# 根据层次遍历列表构建二叉树
def build_tree(level_order):
    if not level_order or level_order[0] == -1:
        return None
    root = TreeNode(level_order[0])
    queue = [root]
    i = 1
    while i < len(level_order):
        node = queue.pop(0)
        if level_order[i] != -1:
            node.left = TreeNode(level_order[i])
            queue.append(node.left)
        i += 1
        if i < len(level_order) and level_order[i] != -1:
            node.right = TreeNode(level_order[i])
            queue.append(node.right)
        i += 1
    return root


# 前序遍历
def preorderTraversal(root):
    if root is None:
        return []
    return [root.val] + preorderTraversal(root.left) + preorderTraversal(root.right)


if __name__ == "__main__":
    # 读取输入
    level_order = list(map(int, input().split(',')))

    # 构建树并进行前序遍历
    root = build_tree(level_order)
    result = preorderTraversal(root)

    # 输出结果
    print(" ".join(map(str, result)))