13

I am implementing a graph library and I want to include some basic graph algorithms in it. I have read about planar graphs and I decided to include in my library a function that checks if a graph is planar. I found on the web many efficient algorithms, but they all have the same drawback: they are very hard to implement.

So here is my question: does there exist an algorithm for planarity checking which is easy to understand and to implement?

user1105
  • 591
  • 1
  • 6
  • 12
Rondogiannis Aristophanes
  • 133
  • 1
  • 9
  • 2
    You could just use Sage which has a very efficient planarity algorithm built in. You won't need to understand it to use it. It also will probably have any other functions you want, or if it doesn't, you could help make Sage better for everyone by implementing just those one or two algorithms you need that are not already built-in. No need to reinvent the wheel. http://www.sagemath.org/ – GeoffDS Aug 08 '12 at 17:50
  • 1
    Actually it is not that hard to implement the planarity-checking algorithm; in my college people did it in their second programming course (the first one where they learnt C). It just takes some time and patience. – ShreevatsaR Nov 01 '12 at 17:51
  • 1
    What language are you implementing your library in, BTW? – ShreevatsaR Nov 02 '12 at 05:47
  • @ShreevatsaR in c++ – Rondogiannis Aristophanes Nov 02 '12 at 18:02

3 Answers3

16

Several criteria for planarity are listed here: http://en.wikipedia.org/wiki/Planar_graph.

Kuratowski's Theorem gives one possible algorithm, although it is quite slow. http://en.wikipedia.org/wiki/Planar_graph#Kuratowski.27s_and_Wagner.27s_theorems

Hopcraft and Tarjan devised a linear-time algorithm. http://en.wikipedia.org/wiki/Planarity_testing#Path_addition_method

You may find good answers on Stack Overflow.

https://stackoverflow.com/questions/9173490/python-networkx

https://stackoverflow.com/questions/1854711/how-to-check-if-a-graph-is-a-planar-graph-or-not

Community
  • 1
khu
  • 534
6

I think @K. Hu's suggestion of an algorithm based on Kuratowski's theorem must be the easiest to understand and implement. Let's try to write it in pseudocode:

is_planar(G):
  If G is the empty graph, return TRUE.
  If G is isomorphic to K_(3,3) or K_5, return FALSE.
  For each vertex V of G:
    Let H be a copy of G with V and all adjacent edges removed.
    If not is_planar(H), return FALSE.
  For each edge E of G:
    Let H be a copy of G with E removed.
    If not is_planar(H), return FALSE.
  For each edge E of G:
    Let H be a copy of G with E contracted.
    If not is_planar(H), return FALSE.
  return TRUE.

This will typically only terminate in a reasonable amount of time for very small graphs. However, there are optimizations such as memoization that can improve the running time somewhat without altering the overall structure of the program. Possibly it could be extended to work for larger graphs of an unpathological nature, or at least those with certain nice properties.

Additionally, it has the benefit of generalizing easily to other topological surfaces as long as the forbidden minors are known.

Dan Brumleve
  • 17,735
0

The Left right planarity test isn't very hard to understand. The idea is to use a deep first search spanning tree $T$ of the graph as a skeleton and try to find a subset $L$ of the edges of the cograph $C$ of $T$ such that $R=C-L$ and $L$ can be placed on the right and the left of the tree to obtain a planar graph. If it works the graph is planar else non planar. If the tree is a Hamilton path the situation is rather simple else there is some more things to consider.

enter image description here

Lehs
  • 14,344
  • 4
  • 30
  • 83