存储结构由哪两种基本的存储方法实现？画出简单示意图

存储结构通常由顺序存储和链式存储这两种基本的存储方法实现。

1. 顺序存储：是指数据元素存放在地址连续的存储单元里，其数据间的逻辑关系和物理关系是一致的。在顺序存储结构中，每个数据元素可以通过它的序号（或称为下标、位置）直接访问。例如，数组就是典型的顺序存储结构。

示例的简单示意图如下（以数组为例）：

   地址:  0   1   2   3   4
   数组:  | a | b | c | d | e |

2. 链式存储：指的是数据元素的存储空间可以是不连续的，数据元素之间通过指针来连接，每个节点包含数据本身和指向下一个节点的指针。在链式存储结构中，访问数据元素需要通过指针顺序查找。例如，链表就是典型的链式存储结构。

示例的简单示意图如下（以单链表为例）：

   头节点 -->> 数据域 --| 指针域
                数据a       |-----> 数据域 --| 指针域
                               数据b       |-----> 数据域 --| 指针域
                                              数据c       |-----> NULL

相关问题

实现图的存储，输出存储结构示意图

常见的图的存储结构有两种：邻接矩阵和邻接表。

邻接矩阵是一个二维数组，其中元素 a[i][j] 表示顶点 i 与顶点 j 之间是否有边相连，如果有则为边的权值，否则为 0。对于无向图来说，邻接矩阵是对称的，即 a[i][j] = a[j][i]。

示意图：

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

邻接表则是将每个顶点及其相邻的顶点用链表方式存储，对于无向图来说，每条边需要存储两次，即分别存储在两个顶点的链表中。

示意图：

1: 2 -> 3
2: 1 -> 3 -> 4
3: 1 -> 2 -> 4
4: 2 -> 3

以上示意图演示了一个无向图的存储结构，其中顶点用数字表示，数字前面的箭头表示该顶点的相邻顶点。

实现图的存储，输出存储结构示意图的代码

以下是使用邻接矩阵和邻接表两种方式实现图的存储，并输出存储结构示意图的 Python 代码示例：

# 使用邻接矩阵实现图的存储，并输出存储结构示意图
class Graph:
    def __init__(self, vertices):
        self.vertices = vertices
        self.adj_matrix = [[0] * vertices for _ in range(vertices)]

    def add_edge(self, v1, v2, weight=1):
        self.adj_matrix[v1][v2] = weight
        self.adj_matrix[v2][v1] = weight  # 对于无向图，邻接矩阵是对称的

    def print_graph(self):
        for row in self.adj_matrix:
            print(row)

g = Graph(4)
g.add_edge(0, 1)
g.add_edge(0, 2)
g.add_edge(1, 2)
g.add_edge(1, 3)
g.add_edge(2, 3)
g.print_graph()

# 输出：
# [0, 1, 1, 0]
# [1, 0, 1, 1]
# [1, 1, 0, 1]
# [0, 1, 1, 0]


# 使用邻接表实现图的存储，并输出存储结构示意图
class Node:
    def __init__(self, val):
        self.val = val
        self.next = None

class Graph:
    def __init__(self, vertices):
        self.vertices = vertices
        self.adj_list = [None] * vertices

    def add_edge(self, v1, v2):
        # 添加 v2 到 v1 的链表中
        node = Node(v2)
        node.next = self.adj_list[v1]
        self.adj_list[v1] = node

        # 添加 v1 到 v2 的链表中
        node = Node(v1)
        node.next = self.adj_list[v2]
        self.adj_list[v2] = node

    def print_graph(self):
        for i in range(self.vertices):
            print(i, end=": ")
            node = self.adj_list[i]
            while node:
                print(node.val, end=" -> ")
                node = node.next
            print("None")

g = Graph(4)
g.add_edge(0, 1)
g.add_edge(0, 2)
g.add_edge(1, 2)
g.add_edge(1, 3)
g.add_edge(2, 3)
g.print_graph()

# 输出：
# 0: 2 -> 1 -> None
# 1: 3 -> 2 -> 0 -> None
# 2: 3 -> 1 -> 0 -> None
# 3: 2 -> 1 -> None

以上代码中，使用 `Graph` 类来表示图，`add_edge` 方法用于添加边，`print_graph` 方法用于输出存储结构示意图。其中使用 `adj_matrix` 数组来存储邻接矩阵，使用 `adj_list` 数组来存储邻接表，每个链表的头结点表示该顶点相邻的顶点。