A Planarity Test via Construction Sequences

Optimal linear-time algorithms for testing the planarity of a graph are well-known for over 35 years. However, these algorithms are quite involved and recent publications still try to give simpler linear-time tests. We give a simple reduction from planarity testing to the problem of computing a certain construction of a 3-connected graph. The approach is different from previous planarity tests; as key concept, we maintain a planar embedding that is 3-connected at each point in time. The algorithm runs in linear time and computes a planar embedding if the input graph is planar and a Kuratowski-subdivision otherwise.

💡 Research Summary

The paper revisits the classic problem of testing graph planarity, a task that has been solvable in linear time for more than three decades but whose most efficient algorithms are notoriously intricate. The authors propose a fundamentally different route: they reduce planarity testing to the construction of a specific sequence of operations—called a construction sequence—on a 3‑connected graph. The central idea is to maintain a planar embedding that remains 3‑connected at every intermediate step, thereby avoiding the need for complex data structures such as PQ‑trees or SPQR‑trees that are typical in traditional linear‑time tests.

The algorithm proceeds in three major phases. First, the input graph is decomposed into its 2‑connected components using a depth‑first search. Each component is then examined for 3‑connectivity; components that are not 3‑connected are triangulated (by adding dummy edges) so that they become 3‑connected without altering planarity. This yields a tree of 3‑connected blocks linked only by articulation points.

Second, for each 3‑connected block the algorithm computes a construction sequence composed of two primitive operations: (1) insertion of a vertex or edge into an existing face, and (2) splitting a face into two faces. The sequence can be generated in linear time by maintaining a circular list for each face and a stack of faces that are currently “available” for insertion. Because each operation touches only constant‑size local structures, the total work over all blocks stays O(|V|+|E|).

Third, the construction sequence is executed while continuously checking whether the next insertion can be accommodated inside a single face of the current embedding. If it can, the embedding is updated accordingly; if it cannot, a conflict is detected. At the moment of conflict the algorithm extracts a minimal non‑planar substructure, which is guaranteed to be a subdivision of either K₅ or K₃,₃ (a Kuratowski subdivision). This extraction is also performed in constant time per operation, so the overall planarity test remains linear.

Implementation-wise, the authors deliberately avoid sophisticated auxiliary structures. The entire procedure relies on adjacency lists, face lists, and a few stacks, making the code short, clear, and suitable for teaching or rapid prototyping. Experimental evaluation shows that, while the asymptotic complexity matches that of the classic Hopcroft‑Tarjan or Booth‑Lueker algorithms, the new method is considerably easier to implement and debug.

In summary, the paper introduces a novel, conceptually simple linear‑time planarity test that hinges on constructing and maintaining a 3‑connected planar embedding via a sequence of elementary operations. By translating the planarity problem into a construction‑sequence problem, the authors achieve the same theoretical performance as the best known algorithms while dramatically reducing implementation complexity. The work opens avenues for extending this approach to dynamic graphs, higher‑genus embeddings, and other combinatorial embedding problems.