如何检查图是否为无向图？

Question

Currently, I am creating a function to check whether a graph is un-directed. The way, my graphs are stored are in this way. This is a un-directed graph of 3 nodes, 1, 2, 3.

graph = {1: {2:{...}, 3:{...}}, 2: {1:{...}, 3:{...}}, 3: {1:{...}, 2:{...}}}

the {...} represents alternating layers of the dictionaries for the connections in each of the nodes. It is infinitely recurring, since it is nested in each other.

More details about graph:

1. the keys refer to the node, and it's values refer to a dict, with the nodes that are connected to the key.
2. Example: two nodes (1, 2) with an undirected edge: graph = {1: {2: {1: {...}}}, 2: {1: {2: {...}}}}
3. Example2: two nodes (1, 2) with a directed edge from 1 to 2: graph = {1: {2: {}}, 2: {}}

My current way of figuring out whether a graph is un-directed or not, is by checking whether the number of edges in the graph is equal to (n*(n-1))/2 (n represents the number of nodes), but this cannot differentiate between 15 directed edges and 15 un-directed edges, so what other way can i confirm that my graph is undirected?

Answer 1

First off, I think you're abusing terminology by calling a graph with edges in both directions "undirected". In a real undirected graph, there is no notion of direction to an edge, which often means you don't need redundant direction information in the graph's representation in a computer program. What you have is a directed graph, and you want to see if it could be represented by an undirected graph, even though you're not doing so yet.

I'm not sure there's any easier way to do this than by checking every edge in the graph to see if the reversed edge also exists. This is pretty easy with your graph structure, just loop over the verticies and check if there is a returning edge for every outgoing edge:

def undirected_compatible(graph):
    for src, edges in graph.items():          # edges is dict of outgoing edges from src
        for dst, dst_edges in edges.items():  # dst_edges is dict of outgoing edges from dst
            if src not in dst_edges:
                return False
    return True

I'd note that a more typical way of describing a graph like yours would be to omit the nested dictionaries and just give a list of destinations for the edges. A fully connected 3-node graph would be:

{1: [2, 3], 2: [1, 3], 3: [1, 2]}

You can get the same information from this graph as your current one, you'd just need an extra indirection to look up the destination node in the top level graph dict, rather than having it be the value of the corresponding key in the edge container already. A version of my function above for this more conventional structure would be:

def undirected_compatible(graph):
    for src, edges in graph.items():
        for dst in edges:
            if src not in graph[dst]:
                return False
    return True

The not in test may make this slower for large graphs, since searching a list for an item is less asymptotically efficient than checking if a key is in a dictionary. If you needed the higher performance, you could use sets instead of lists, to speed up the membership tests.