（1）先任意创建一个图；（2）图的DFS,BFS的递归和非递归算法的实现；（3）最小生成树（两个算法）的实现，求连通分量的实现；（4）要求用邻接矩阵、邻接表结构存储实现

<<
为了回答您的问题，我将分别介绍图的创建、深度优先搜索（DFS）、广度优先搜索（BFS）、最小生成树和连通分量的算法实现，并使用邻接矩阵和邻接表作为存储结构。请看以下代码示例：

1. 创建图的邻接矩阵表示：

def create_graph_matrix(num_vertices):
    # 初始化一个num_vertices x num_vertices的矩阵，所有值设为0
    graph = [[0 for column in range(num_vertices)]
             for row in range(num_vertices)]
    return graph

2. 创建图的邻接表表示：

class GraphNode:
    def __init__(self, value):
        self.vertex = value
        self.next = None

class Graph:
    def __init__(self, size):
        self.adj_list = [None] * size
    
    def add_edge(self, src, dest):
        # 添加无向边
        node = GraphNode(dest)
        node.next = self.adj_list[src]
        self.adj_list[src] = node

3. DFS递归实现：

def dfs_recursive(graph, start_vertex, visited=None):
    if visited is None:
        visited = set()
    visited.add(start_vertex)
    print(start_vertex)
    for i in range(len(graph)):
        if graph[start_vertex][i] == 1 and i not in visited:
            dfs_recursive(graph, i, visited)

4. DFS非递归实现（使用栈）：

def dfs_iterative(graph, start_vertex):
    visited = set()
    stack = [start_vertex]
    
    while stack:
        vertex = stack.pop()
        if vertex not in visited:
            print(vertex)
            visited.add(vertex)
            for i in range(len(graph)):
                if graph[vertex][i] == 1 and i not in visited:
                    stack.append(i)

5. BFS递归实现：

from collections import deque

def bfs_recursive(graph, start_vertex, visited=None):
    if visited is None:
        visited = set()
    queue = deque([start_vertex])
    
    while queue:
        vertex = queue.popleft()
        if vertex not in visited:
            print(vertex)
            visited.add(vertex)
            for i in range(len(graph)):
                if graph[vertex][i] == 1 and i not in visited:
                    queue.append(i)

6. BFS非递归实现（使用队列）：

from collections import deque

def bfs_iterative(graph, start_vertex):
    visited = set()
    queue = deque([start_vertex])
    
    while queue:
        vertex = queue.popleft()
        if vertex not in visited:
            print(vertex)
            visited.add(vertex)
            for i in range(len(graph)):
                if graph[vertex][i] == 1 and i not in visited:
                    queue.append(i)

7. 最小生成树算法（Kruskal和Prim）实现：

# Kruskal算法使用并查集，这里不展开实现，Prim算法如下：

def prim(graph, start_vertex):
    num_vertices = len(graph)
    in_mst = [False] * num_vertices
    key = [float('inf')] * num_vertices
    parent = [-1] * num_vertices
    
    key[start_vertex] = 0
    
    for _ in range(num_vertices):
        u = min_key(key, in_mst)
        in_mst[u] = True
        
        for v in range(num_vertices):
            if graph[u][v] > 0 and not in_mst[v] and graph[u][v] < key[v]:
                key[v] = graph[u][v]
                parent[v] = u
    return parent

def min_key(key, in_mst):
    min_val = float('inf')
    min_index = -1
    for v in range(len(key)):
        if key[v] < min_val and not in_mst[v]:
            min_val = key[v]
            min_index = v
    return min_index

8. 求连通分量：

def find_connected_components(graph):
    visited = set()
    components = []
    
    for vertex in range(len(graph)):
        if vertex not in visited:
            component = []
            dfs_recursive(graph, vertex, visited, component)
            components.append(component)
    return components

# 辅助函数，用于DFS时收集连通分量
def dfs_recursive(graph, start_vertex, visited, component):
    visited.add(start_vertex)
    component.append(start_vertex)
    for i in range(len(graph)):
        if graph[start_vertex][i] == 1 and i not in visited:
            dfs_recursive(graph, i, visited, component)

请注意，以上代码仅为示例，实现可能需要根据具体情况进行调整。为了保证代码的正确性和完整性，您可能需要添加额外的辅助函数或者数据结构定义。