networkx无向图用什么代码

使用NetworkX创建一个简单的无向图可以使用以下代码：

import networkx as nx

# 创建一个无向图
G = nx.Graph()

# 添加节点
G.add_node(1)
G.add_node(2)
G.add_node(3)

# 添加边
G.add_edge(1,2)
G.add_edge(2,3)

# 绘制图形
nx.draw(G, with_labels=True)

这个代码创建了一个无向图对象 `G`，并添加了三个节点和两条边。然后使用 `nx.draw()` 函数绘制了这个无向图。

相关问题

networkx中找出无向图中所有环的代码？

### 回答1：
可以使用networkx中的nx.cycle_basis()函数来找出无向图中的所有环。

代码如下:

import networkx as nx

G = nx.Graph()
# 添加边
G.add_edges_from([(1,2), (2,3), (3,1), (3,4), (4,5), (5,3)])

cycles = nx.cycle_basis(G)
print(cycles)

这将输出所有环的列表,如：

[[1, 2, 3], [3, 4, 5, 3]]

注意：在有向图中使用nx.simple_cycles()函数来找环

### 回答2：
在networkx中，可以使用深度优先搜索算法（DFS）找出无向图中的所有环。下面是一个简单的代码示例：

import networkx as nx

def find_cycles(graph):
    cycles = []
    visited = set()

    def dfs(node, path):
        visited.add(node)
        for neighbor in graph.neighbors(node):
            if neighbor not in visited:
                dfs(neighbor, path + [neighbor])
            elif neighbor == path[0]:
                cycles.append(path + [neighbor])

    for node in graph.nodes():
        if node not in visited:
            dfs(node, [node])
    
    return cycles

# 创建无向图
G = nx.Graph()
G.add_edges_from([(1, 2), (2, 3), (3, 4), (4, 1), (2, 4)])

# 查找图中的环
cycles = find_cycles(G)
print(cycles)

这个代码使用了递归的深度优先搜索算法来遍历无向图中的节点。首先，我们定义一个内部的`dfs`函数，它将当前节点加入到已访问的集合中，并遍历当前节点的邻居。如果邻居节点还未被访问，则递归调用`dfs`函数，并将邻居节点加入到路径中。如果邻居节点已经在路径中，那么我们找到了一个环，将路径添加到环的列表中。最后，我们遍历图中的所有节点，并调用`dfs`函数来查找所有的环。输出的结果是包含所有环的列表。

运行这段代码后，输出应为：`[[1, 2, 4], [1, 4, 3, 2]]`。这表示在给定的无向图中，有两个环：1->2->4->1和1->4->3->2->1。

### 回答3：
要在networkx中找出无向图中的所有环，可以使用DFS算法（深度优先搜索）来实现。具体代码如下：

import networkx as nx

def find_cycles(graph):
    cycles = []
    visited = set()  # 记录已访问的节点集合

    # 定义DFS递归函数
    def dfs(node, start, path):
        visited.add(node)  # 将当前节点标记为已访问

        # 遍历当前节点的邻居节点
        for neighbor in graph.neighbors(node):
            if neighbor == start and len(path) > 2:
                # 如果邻居节点为起始节点，且路径长度大于2，说明找到一个环
                cycles.append(path + [start])
            elif neighbor not in visited:
                # 如果邻居节点未访问过，则递归调用DFS函数
                dfs(neighbor, start, path + [neighbor])

        visited.remove(node)  # 递归返回后，将当前节点从已访问集合中移除

    # 对图中每个节点进行DFS搜索
    for node in graph.nodes():
        dfs(node, node, [node])

    return cycles

# 创建一个简单的无向图
G = nx.Graph()
G.add_edges_from([(1, 2), (2, 3), (3, 1), (2, 4), (4, 5), (5, 1)])

# 调用函数找出所有环
cycles = find_cycles(G)
print(cycles)

以上代码中，我们首先定义了一个 `find_cycles` 函数来实现DFS搜索，参数为一个无向图。在DFS搜索中，我们使用一个 `visited` 集合来记录已访问过的节点，遍历每个节点并将其标记为已访问，并进行DFS递归搜索。
当访问到一个节点的邻居节点时，首先判断其是否为起始节点且路径长度大于2，如果是则说明找到一个环，将路径存入 `cycles` 列表中。如果邻居节点未被访问过，则以该节点为新的起始节点进行递归调用。最后递归返回后，将当前节点从已访问集合中移除。
最后我们可以创建一个简单的无向图，并调用 `find_cycles` 函数来找出所有环。以上代码输出结果为：`[[1, 2, 3, 1], [1, 2, 4, 5, 1]]`，表示找到了两个环。

NetworkX 绘图10种代码

下面是使用NetworkX绘制常见图形的10种代码：

1. 无向图

import networkx as nx

G = nx.Graph()

G.add_edge(1, 2)
G.add_edge(2, 3)
G.add_edge(3, 1)

nx.draw(G, with_labels=True)

2. 有向图

import networkx as nx

G = nx.DiGraph()

G.add_edge(1, 2)
G.add_edge(2, 3)
G.add_edge(3, 1)

nx.draw(G, with_labels=True)

3. 加权图

import networkx as nx

G = nx.Graph()

G.add_edge(1, 2, weight=0.5)
G.add_edge(1, 3, weight=0.75)
G.add_edge(2, 3, weight=0.9)

pos = nx.spring_layout(G)
nx.draw(G, pos, with_labels=True)
labels = nx.get_edge_attributes(G, 'weight')
nx.draw_networkx_edge_labels(G, pos, edge_labels=labels)

4. 大图布局

import networkx as nx
import matplotlib.pyplot as plt

G = nx.Graph()

G.add_edge(1, 2)
G.add_edge(2, 3)
G.add_edge(3, 1)

pos = nx.spring_layout(G, k=0.5, iterations=50)
nx.draw(G, pos, with_labels=True)
plt.show()

5. 圆形布局

import networkx as nx
import matplotlib.pyplot as plt

G = nx.Graph()

G.add_edge(1, 2)
G.add_edge(2, 3)
G.add_edge(3, 1)

pos = nx.circular_layout(G)
nx.draw(G, pos, with_labels=True)
plt.show()

6. 随机布局

import networkx as nx
import matplotlib.pyplot as plt

G = nx.Graph()

G.add_edge(1, 2)
G.add_edge(2, 3)
G.add_edge(3, 1)

pos = nx.random_layout(G)
nx.draw(G, pos, with_labels=True)
plt.show()

7. Shell布局

import networkx as nx
import matplotlib.pyplot as plt

G = nx.Graph()

G.add_edge(1, 2)
G.add_edge(2, 3)
G.add_edge(3, 1)

pos = nx.shell_layout(G)
nx.draw(G, pos, with_labels=True)
plt.show()

8. Spectral布局

import networkx as nx
import matplotlib.pyplot as plt

G = nx.Graph()

G.add_edge(1, 2)
G.add_edge(2, 3)
G.add_edge(3, 1)

pos = nx.spectral_layout(G)
nx.draw(G, pos, with_labels=True)
plt.show()

9. Planar布局

import networkx as nx
import matplotlib.pyplot as plt

G = nx.Graph()

G.add_edge(1, 2)
G.add_edge(2, 3)
G.add_edge(3, 1)

pos = nx.planar_layout(G)
nx.draw(G, pos, with_labels=True)
plt.show()

10. Bipartite Graph布局

import networkx as nx
import matplotlib.pyplot as plt

B = nx.Graph()
B.add_nodes_from([1, 2, 3, 4], bipartite=0)
B.add_nodes_from(['a', 'b', 'c'], bipartite=1)
B.add_edges_from([(1, 'a'), (1, 'b'), (2, 'b'), (2, 'c'), (3, 'c'), (4, 'a')])

pos = nx.bipartite_layout(B, [1, 2, 3, 4])
nx.draw(B, pos, with_labels=True)
plt.show()

以上是10种常见的使用 NetworkX 绘图的代码示例，可以根据需求选择对应的代码。