数据结构图的基本操作与实现。要求:(1)输入含n个顶点和e条边的图;(2)求每个顶点的度，输出结果; (3)指定任意顶点x为初始顶点，对图作DES遍历。输出DFS顶点序列(提示使用一个栈实现DFS);(4)指定任意顶点x为初始顶点，对图作bFS遍历输出BFS顶点序列(提示使用一个队列实现DFS);(5)输入顶点x，查找图，若存在含x的顶点，则册除该顶点及与之相关的边，并作DFS遍历，否则输出信息“无x”; (6)判断图是否连通，输出信息“YES/NO”; 如果选用的存储结构是邻接矩阵，则用邻接矩阵的信息生成图的邻接表，反之亦然。

好的，我会尽力回答你的问题。这是一个关于图的问题，涉及到图的基本操作和实现。我会分步骤回答你的问题。

1. 输入含n个顶点和e条边的图，求每个顶点的度，输出结果。

这个问题可以用邻接矩阵或邻接表来解决。如果使用邻接矩阵，则每个顶点的度就是该顶点所在行或列的元素之和。如果使用邻接表，则每个顶点的度就是与其相关的边的数量。具体实现可以参考以下伪代码：

// 邻接矩阵实现
for i = 1 to n:
    degree = 0
    for j = 1 to n:
        if matrix[i][j] != 0:
            degree += 1
    print("Vertex ", i, " has degree ", degree)

// 邻接表实现
for i = 1 to n:
    degree = 0
    for each edge (i, j) in adjacency list:
        degree += 1
    print("Vertex ", i, " has degree ", degree)

2. 指定任意顶点x为初始顶点，对图作DFS遍历。输出DFS顶点序列(提示使用一个栈实现DFS)。

深度优先搜索（DFS）可以用递归或栈来实现。以下代码演示了如何使用栈来实现DFS遍历：

// 非递归实现DFS
dfs_stack = [start_vertex]
visited = set()
while dfs_stack:
    vertex = dfs_stack.pop()
    if vertex not in visited:
        visited.add(vertex)
        print(vertex)
        for neighbor in adjacency_list[vertex]:
            dfs_stack.append(neighbor)

其中，dfs_stack是存放顶点的栈，visited是存放已被访问过的顶点的集合。遍历过程中，从栈中弹出一个顶点，如果该顶点未被访问过，则标记为已访问，输出该顶点，并将其邻居顶点加入栈中。

3. 指定任意顶点x为初始顶点，对图作bFS遍历输出BFS顶点序列(提示使用一个队列实现DFS)。

广度优先搜索（BFS）可以用队列来实现。以下代码演示了如何使用队列来实现BFS遍历：

// 队列实现BFS
bfs_queue = deque([start_vertex])
visited = set()
while bfs_queue:
    vertex = bfs_queue.popleft()
    if vertex not in visited:
        visited.add(vertex)
        print(vertex)
        for neighbor in adjacency_list[vertex]:
            bfs_queue.append(neighbor)

其中，bfs_queue是存放顶点的队列，visited是存放已被访问过的顶点的集合。遍历过程中，从队列的左侧弹出一个顶点，如果该顶点未被访问过，则标记为已访问，输出该顶点，并将其邻居顶点加入队列的右侧。

4. 输入顶点x，查找图，若存在含x的顶点，则册除该顶点及与之相关的边，并作DFS遍历，否则输出信息“无x”。

这个问题可以先进行图的遍历，找到所有含有顶点x的连通分量，然后将这些连通分量从图中删除。以下是代码实现：

// 对图进行遍历，找到所有包含x的连通分量
visited = set()
components = []
for vertex in adjacency_list:
    if vertex not in visited:
        component = []
        dfs_stack = [vertex]
        while dfs_stack:
            v = dfs_stack.pop()
            if v not in visited:
                visited.add(v)
                component.append(v)
                for neighbor in adjacency_list[v]:
                    dfs_stack.append(neighbor)
        if x in component:
            components.append(component)

// 删除所有包含x的连通分量
for component in components:
    for vertex in component:
        adjacency_list.pop(vertex, None)
    for vertex in adjacency_list:
        adjacency_list[vertex] = [v for v in adjacency_list[vertex] if v not in component]

// 如果存在包含x的连通分量，则进行DFS遍历
if components:
    dfs_stack = [start_vertex]
    visited = set()
    while dfs_stack:
        vertex = dfs_stack.pop()
        if vertex not in visited:
            visited.add(vertex)
            print(vertex)
            for neighbor in adjacency_list[vertex]:
                dfs_stack.append(neighbor)
else:
    print("无x")

5. 判断图是否连通，输出信息“YES/NO”。

判断图是否连通可以使用DFS或BFS遍历来实现。如果遍历过程中发现所有顶点都被访问过，则说明图是连通的。以下代码演示了用DFS来实现判断图是否连通的过程：

// 判断图是否连通
visited = set()
dfs_stack = [start_vertex]
while dfs_stack:
    vertex = dfs_stack.pop()
    if vertex not in visited:
        visited.add(vertex)
        for neighbor in adjacency_list[vertex]:
            dfs_stack.append(neighbor)

if len(visited) == len(adjacency_list):
    print("YES")
else:
    print("NO")

6. 如果选用的存储结构是邻接矩阵，则用邻接矩阵的信息生成图的邻接表，反之亦然。

如果存储结构是邻接矩阵，则可以将每个非零元素转换为一条边，生成邻接表。以下是代码实现：

// 邻接矩阵转邻接表
adjacency_list = {}
for i = 1 to n:
    adjacency_list[i] = []
    for j = 1 to n:
        if matrix[i][j] != 0:
            adjacency_list[i].append(j)

如果存储结构是邻接表，则可以使用字典来存储邻接表中的信息，然后生成邻接矩阵。以下是代码实现：

// 邻接表转邻接矩阵
matrix = [[0] * n for _ in range(n)]
for vertex in adjacency_list:
    for neighbor in adjacency_list[vertex]:
        matrix[vertex][neighbor] = 1