1）分别用邻接矩阵和邻接表存储图，输入一定数量的顶点和边，建立一个图； 2）实现图的深度优先遍历并输出结果； 3）实现图的广度优先遍历并输出结果。

好的，我会根据您的要求回答您的问题。

1. 邻接矩阵和邻接表存储图

邻接矩阵是一个二维数组，其中矩阵的行和列分别表示图中的顶点，矩阵中的元素表示两个顶点之间是否存在一条边。如果顶点 i 和顶点 j 之间存在一条边，那么矩阵中的元素 a[i][j] 的值为 1，否则为 0。邻接矩阵的缺点是当图的边数很大时，会占用大量的存储空间。

邻接表则是使用链表来存储图的边。对于每个顶点，都会创建一个链表，链表中存储该顶点所连接的其他顶点。邻接表的优点是可以有效地存储稀疏图，而且可以快速遍历每个顶点所连接的其他顶点。

以下是使用 Python 语言实现邻接矩阵和邻接表存储图的代码：

# 使用邻接矩阵存储图
class Graph:
    def __init__(self, num_vertices):
        self.adj_matrix = [[0] * num_vertices for _ in range(num_vertices)]
        self.num_vertices = num_vertices

    def add_edge(self, i, j):
        # 添加边
        self.adj_matrix[i][j] = 1
        self.adj_matrix[j][i] = 1

    def remove_edge(self, i, j):
        # 删除边
        self.adj_matrix[i][j] = 0
        self.adj_matrix[j][i] = 0

    def __str__(self):
        # 打印邻接矩阵
        return '\n'.join([' '.join([str(item) for item in row]) for row in self.adj_matrix])

# 使用邻接表存储图
class Graph:
    def __init__(self, num_vertices):
        self.adj_list = [[] for _ in range(num_vertices)]
        self.num_vertices = num_vertices

    def add_edge(self, i, j):
        # 添加边
        self.adj_list[i].append(j)
        self.adj_list[j].append(i)

    def remove_edge(self, i, j):
        # 删除边
        self.adj_list[i].remove(j)
        self.adj_list[j].remove(i)

    def __str__(self):
        # 打印邻接表
        res = ""
        for i in range(self.num_vertices):
            res += str(i) + " -> " + ", ".join([str(x) for x in self.adj_list[i]]) + "\n"
        return res

2. 图的深度优先遍历

深度优先遍历是一种重要的图遍历算法，它可以用来查找图中的所有顶点和边，并且可以用来检测图中的环。深度优先遍历的基本思想是从某个顶点开始，沿着一条路径遍历图，直到到达最后一个顶点，然后返回到上一个顶点，继续遍历未遍历的路径，直到所有顶点都被遍历为止。

以下是使用 Python 语言实现图的深度优先遍历的代码：

class Graph:
    def __init__(self, num_vertices):
        self.adj_list = [[] for _ in range(num_vertices)]
        self.visited = [False] * num_vertices
        self.num_vertices = num_vertices

    def add_edge(self, i, j):
        # 添加边
        self.adj_list[i].append(j)
        self.adj_list[j].append(i)

    def dfs(self, v):
        # 深度优先遍历
        self.visited[v] = True
        print(v, end=" ")

        for i in self.adj_list[v]:
            if not self.visited[i]:
                self.dfs(i)

    def __str__(self):
        # 打印邻接表
        res = ""
        for i in range(self.num_vertices):
            res += str(i) + " -> " + ", ".join([str(x) for x in self.adj_list[i]]) + "\n"
        return res

# 测试
g = Graph(5)
g.add_edge(0, 1)
g.add_edge(0, 2)
g.add_edge(1, 2)
g.add_edge(2, 3)
g.add_edge(3, 4)

print("邻接表：")
print(g)
print("深度优先遍历：")
g.dfs(0)

输出结果为：

邻接表：
0 -> 1, 2
1 -> 0, 2
2 -> 0, 1, 3
3 -> 2, 4
4 -> 3
深度优先遍历：
0 1 2 3 4

3. 图的广度优先遍历

广度优先遍历也是一种重要的图遍历算法，它可以用来查找图中的所有顶点和边，并且可以用来计算图的最短路径。广度优先遍历的基本思想是从某个顶点开始，访问相邻的所有顶点，然后访问这些相邻顶点的相邻顶点，以此类推，直到所有顶点都被访问为止。

以下是使用 Python 语言实现图的广度优先遍历的代码：

from collections import deque

class Graph:
    def __init__(self, num_vertices):
        self.adj_list = [[] for _ in range(num_vertices)]
        self.visited = [False] * num_vertices
        self.num_vertices = num_vertices

    def add_edge(self, i, j):
        # 添加边
        self.adj_list[i].append(j)
        self.adj_list[j].append(i)

    def bfs(self, v):
        # 广度优先遍历
        queue = deque([v])
        self.visited[v] = True

        while queue:
            vertex = queue.popleft()
            print(vertex, end=" ")

            for i in self.adj_list[vertex]:
                if not self.visited[i]:
                    queue.append(i)
                    self.visited[i] = True

    def __str__(self):
        # 打印邻接表
        res = ""
        for i in range(self.num_vertices):
            res += str(i) + " -> " + ", ".join([str(x) for x in self.adj_list[i]]) + "\n"
        return res

# 测试
g = Graph(5)
g.add_edge(0, 1)
g.add_edge(0, 2)
g.add_edge(1, 2)
g.add_edge(2, 3)
g.add_edge(3, 4)

print("邻接表：")
print(g)
print("广度优先遍历：")
g.bfs(0)

输出结果为：

邻接表：
0 -> 1, 2
1 -> 0, 2
2 -> 0, 1, 3
3 -> 2, 4
4 -> 3
广度优先遍历：
0 1 2 3 4