无向图的欧拉回路线性时间算法

// 无向图的欧拉回路线性时间算法
// by rappizit@yahoo.com.cn
// 2007-11-02

#include <vector>
#include <list>
#include <stack>
#include <algorithm>
#include <iostream>
using namespace std;

#define pause system("pause")
typedef vector <int> vi;
typedef list <int> li;
typedef vector <li> vli;

vi EulerCircle (vli G)
{
    int n = G.size ();
    int edge = 0;
    for (int i = 0; i < n; i ++)
        {
        int degree = G [i].size ();
        if (degree % 2 || !degree)
            {
            return vi (0);
            }
        edge += degree;
        }
    vi path (edge / 2 + 1);
    stack <int> s;
    int p = 0, i = 0;
    do    {
        if (G [i].empty ())
            {
            do    {
                s.pop ();
                path [p ++] = i;
                } while (!s.empty () && (i = s.top (), G [i].empty ()));
            }
        else    {
            int t = *(G [i].begin ());
            G [i].erase (G [i].begin ());
            G [t].erase (find (G [t].begin (), G [t].end (), i));
            // 使用带有十字链接的双向邻接表可以常数时间地删除边 e(t, i)？！
            s.push (t);
            i = t;
            }
        } while (!s.empty ());
    return path;
}


void main ()
{
    int n, m;
    cin >> n >> m;
    vli G (n);
    while (m --)
        {
        int u, v;
        cin >> u >> v;
        G [u].push_back (v);    // 这里为了迎合书上的例子，每条无向边分两次输入
        }
    vi path = EulerCircle (G);
    if (path.size ())
        {
        for (int i = 0; i < path.size (); i ++)
            {
            cout << path [i] << " ";
            }
        cout << endl;
        }
}

无向图的欧拉回路
采用邻接表存储，vector <list <int>> 类型。
1.如果某点的度数为奇数或零，则没有欧拉回路，返回空的 vector。
2.否则，从标号为 i = 0 的点开始。
3.如果 i 没有邻接点，那么堆栈中所有没有邻接点的点弹出到 vector path 中，如果堆栈非空则 i 赋值为栈顶元素。
  否则取 i 的第一个邻接点 t ，删除它们的边（要在 G 中的两处都删除）。将 t 压栈。i 赋值为 t 。
4.如果堆栈为空，返回 path，否则转 3。
算法时间复杂度为 O (E)。

测试数据：
7 20
0 1
0 2
0 5
0 6
1 0
1 2
2 0
2 3
2 4
2 1
3 4
3 2
4 6
4 5
4 3
4 2
5 4
5 0
6 4
6 0


测试结果：
0 6 4 2 3 4 5 0 2 1 0

过程图示：

First, the program adds the edge 0-1 to the tour and removes it from the adjacency lists (in two places) (top left, lists at left). Second, it adds 1-2 to the tour in the same way (left, second from top). Next, it winds up back at 0 but continues to do another cycle 0-5-4-6-0, winding up back at 0 with no more edges incident upon 0 (right, second from top). Then it pops the isolated vertices 0 and 6 from the stack until 4 is at the top and starts a tour from 4 (right, third from from top), which takes it to 3, 2, and back to 4, where upon it pops all the now-isolated vertices 4, 2, 3, and so forth. The sequence of vertices popped from the stack defines the Euler tour 0-6-4-2-3-4-5-0-2-1-0 of the whole graph.

参考来源：
Algorithms In Java, Part 5 Graph Algorithms , Chapter 17.7 / Java 算法（第 3 版，第 2 卷）——图算法，章节 17.7

PS：但是我是用 C++ 实现的^_^