不调用库，写Fast-newman算法。python代码

Fast Newman算法的核心是贪心算法，它通过不断合并社区来优化模块度。下面提供一份Python代码实现Fast Newman算法。

def fast_newman_algorithm(graph):
    # 初始化每个节点为一个社区
    communities = [[node] for node in graph.nodes()]
    # 计算当前社区的模块度
    modularity = compute_modularity(graph, communities)
    # 标记社区是否合并
    community_merged = True
    while community_merged:
        community_merged = False
        for i in range(len(communities)):
            for j in range(i+1, len(communities)):
                # 计算合并社区后的模块度
                merged_communities = communities.copy()
                merged_communities[i] += merged_communities[j]
                del merged_communities[j]
                new_modularity = compute_modularity(graph, merged_communities)
                if new_modularity > modularity:
                    # 合并社区
                    communities = merged_communities
                    modularity = new_modularity
                    community_merged = True
                    break
            if community_merged:
                break
    return communities

def compute_modularity(graph, communities):
    # 计算图的总边数
    m = graph.number_of_edges()
    # 计算每个社区的度数
    degrees = dict(graph.degree())
    # 计算每个社区内部的边数
    internal_degree = 0
    for community in communities:
        for i in range(len(community)):
            for j in range(i+1, len(community)):
                if graph.has_edge(community[i], community[j]):
                    internal_degree += 1
    # 计算每个社区的模块度
    modularity = 0
    for community in communities:
        for node in community:
            ki = degrees[node]
            ki_in = 0
            for j in community:
                if graph.has_edge(node, j):
                    ki_in += 1
            modularity += (ki_in / m) - ((ki / (2*m)) ** 2)
    return modularity

上述代码中，`fast_newman_algorithm`函数实现了Fast Newman算法，它接受一个图作为输入，返回每个社区的集合。`compute_modularity`函数用于计算当前社区的模块度。在实现过程中，我们使用了图的邻接矩阵来表示图。