对实现图的邻接矩阵存储，包括建立、输出，输出指定顶点的边信息。 实现图的邻接链表存储，包括建立、输出，输出指定顶点的边信息进行复数抽象数据类型ADT的描述

1. 图的邻接矩阵存储：
- 建立：将图的顶点按照某种顺序编号，然后创建一个 n*n 的二维数组，其中 n 表示顶点的个数。数组中的元素 a[i][j] 表示顶点 i 和 j 之间是否有边，如果有，则存储权值，否则为 0 或者一个特殊值表示无穷大。
- 输出：遍历二维数组，输出所有非零元素的行列坐标以及权值。如果需要输出指定顶点的边信息，只需要遍历该顶点所在行或者列的元素即可。

2. 图的邻接链表存储：
- 建立：对于每个顶点，创建一个链表，存储与该顶点相邻的所有顶点及其权值。可以使用数组来存储这些链表的头指针，也可以使用哈希表。
- 输出：遍历每个链表，输出链表中的所有顶点及其权值。如果需要输出指定顶点的边信息，只需要遍历该顶点对应的链表即可。

3. 复数抽象数据类型ADT的描述：
- 数据对象：复数集合。
- 数据关系：复数之间有加、减、乘、除、共轭等运算。
- 基本操作：
1. createComplex(a,b): 创建一个复数 a+b*i。
2. addComplex(c1,c2): 复数加法，返回 c1+c2。
3. subComplex(c1,c2): 复数减法，返回 c1-c2。
4. mulComplex(c1,c2): 复数乘法，返回 c1*c2。
5. divComplex(c1,c2): 复数除法，返回 c1/c2。
6. conjComplex(c): 复数共轭，返回 c 的共轭复数。
7. absComplex(c): 复数模长，返回 c 的模长。

相关问题

Python实现（1）实现图的邻接矩阵存储，包括建立、输出，输出指定顶点的边信息。 （2）实现图的邻接链表存储，包括建立、输出，输出指定顶点的边信息。 （3）实现将图的领接矩阵转换成邻接表，和将邻接表转换成邻接矩阵。 （4）在两种存储结构上，实现深度遍历算法。 （5）在两种存储结构上，实现广度遍历算法。

好的，下面是Python实现的代码：

1. 图的邻接矩阵存储

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, weight):
        self.adj_matrix[i][j] = weight
        self.adj_matrix[j][i] = weight

    def get_edge(self, i, j):
        return self.adj_matrix[i][j]

    def display(self):
        for i in range(self.num_vertices):
            for j in range(self.num_vertices):
                print(self.adj_matrix[i][j], end=' ')
            print()

2. 图的邻接链表存储

from collections import defaultdict

class Graph:
    def __init__(self):
        self.adj_list = defaultdict(list)

    def add_edge(self, u, v, weight):
        self.adj_list[u].append((v, weight))
        self.adj_list[v].append((u, weight))

    def get_edge(self, u, v):
        for edge in self.adj_list[u]:
            if edge[0] == v:
                return edge[1]
        return None

    def display(self):
        for u in self.adj_list:
            print(u, end=' -> ')
            for v, weight in self.adj_list[u]:
                print(f'{v}({weight})', end=' ')
            print()

3. 将图的领接矩阵转换成邻接表，和将邻接表转换成邻接矩阵

class Graph:
    def __init__(self, num_vertices):
        self.adj_matrix = [[0] * num_vertices for _ in range(num_vertices)]
        self.adj_list = defaultdict(list)
        self.num_vertices = num_vertices

    def add_edge(self, i, j, weight):
        self.adj_matrix[i][j] = weight
        self.adj_matrix[j][i] = weight
        self.adj_list[i].append((j, weight))
        self.adj_list[j].append((i, weight))

    def matrix_to_list(self):
        return self.adj_list

    def list_to_matrix(self):
        for u in self.adj_list:
            for v, weight in self.adj_list[u]:
                self.adj_matrix[u][v] = weight
                self.adj_matrix[v][u] = weight
        return self.adj_matrix

4. 图的深度遍历算法

class Graph:
    def __init__(self, num_vertices):
        self.adj_matrix = [[0] * num_vertices for _ in range(num_vertices)]
        self.adj_list = defaultdict(list)
        self.num_vertices = num_vertices

    def add_edge(self, i, j, weight):
        self.adj_matrix[i][j] = weight
        self.adj_matrix[j][i] = weight
        self.adj_list[i].append((j, weight))
        self.adj_list[j].append((i, weight))

    def dfs(self, start):
        visited = [False] * self.num_vertices
        self._dfs(start, visited)

    def _dfs(self, u, visited):
        visited[u] = True
        print(u, end=' ')
        for v, weight in self.adj_list[u]:
            if not visited[v]:
                self._dfs(v, visited)

5. 图的广度遍历算法

from queue import Queue

class Graph:
    def __init__(self, num_vertices):
        self.adj_matrix = [[0] * num_vertices for _ in range(num_vertices)]
        self.adj_list = defaultdict(list)
        self.num_vertices = num_vertices

    def add_edge(self, i, j, weight):
        self.adj_matrix[i][j] = weight
        self.adj_matrix[j][i] = weight
        self.adj_list[i].append((j, weight))
        self.adj_list[j].append((i, weight))

    def bfs(self, start):
        visited = [False] * self.num_vertices
        q = Queue()
        q.put(start)
        visited[start] = True
        while not q.empty():
            u = q.get()
            print(u, end=' ')
            for v, weight in self.adj_list[u]:
                if not visited[v]:
                    visited[v] = True
                    q.put(v)

您可以根据需要调用这些方法来实现您的需求。

满足邻接矩阵:建立所给无向带权图的邻接矩阵存储并输出该矩阵。 邻接表:建立所给无向图的邻接表

好的，我可以回答你的问题。首先是邻接矩阵的问题：

假设给定的无向带权图有 $n$ 个顶点，那么我们可以用一个 $n\times n$ 的矩阵 $M$ 来表示它的邻接矩阵。其中 $M_{i,j}$ 表示顶点 $i$ 和顶点 $j$ 之间的边权值，如果它们之间没有边相连，那么 $M_{i,j}$ 就为无穷大。下面是一个示例代码：

n = 5  # 假设有5个顶点
edges = [(0, 1, 2), (0, 2, 1), (1, 2, 3), (1, 3, 4), (2, 3, 5), (2, 4, 4), (3, 4, 6)]  # 给出边的信息
INF = float('inf')  # 用一个极大值表示两个顶点之间没有边

# 初始化邻接矩阵
M = [[INF] * n for _ in range(n)]

# 填充邻接矩阵
for i, j, w in edges:
    M[i][j] = M[j][i] = w

# 输出邻接矩阵
for i in range(n):
    for j in range(n):
        if M[i][j] == INF:
            print('{:>5}'.format('INF'), end='')
        else:
            print('{:>5}'.format(M[i][j]), end='')
    print()

接下来是邻接表的问题：

邻接表是一种更为紧凑的图表示方法，对于每个顶点，我们用一个链表或数组存储与之相邻的顶点。具体来说，我们可以用一个长度为 $n$ 的数组 $A$ 来表示整个图的邻接表，其中 $A[i]$ 存储顶点 $i$ 的邻接表。邻接表中每个元素可以是一个链表或数组，存储与该顶点相邻的顶点。下面是一个示例代码：

n = 5  # 假设有5个顶点
edges = [(0, 1), (0, 2), (1, 2), (1, 3), (2, 3), (2, 4), (3, 4)]  # 给出边的信息

# 初始化邻接表
A = [[] for _ in range(n)]

# 填充邻接表
for i, j in edges:
    A[i].append(j)
    A[j].append(i)

# 输出邻接表
for i in range(n):
    print('{}: {}'.format(i, A[i]))

注意，上述代码中邻接表中的元素是一个列表，存储与该顶点相邻的顶点编号。如果要存储带权图，可以将列表中的元素改为元组，第一个元素表示相邻的顶点编号，第二个元素表示边权值。