欧拉树之旅

树是连通图的概括，其中它有 N 个节点，这些节点恰好有 N-1 条边，即每对顶点之间有一条边。求邻接表表示的树的欧拉之旅。
例子：
输入 ：

输出：1 2 3 2 4 2 1
输入 ：

输出：1 5 4 2 4 3 4 5 1

欧拉之旅被定义为一种遍历树的方式，这样当我们访问它时，每个顶点都被添加到之旅中（从父顶点向下移动或从子顶点返回）。我们从根开始，在访问完所有顶点后回到根。
它需要恰好 2*N-1 个顶点来存储欧拉环。

方法：我们将在树上运行 DFS（深度优先搜索）算法：

(1)访问根节点，即1
可见[1]=1，欧拉[0]=1
为所有未访问的相邻节点运行 dfs()(2)
(2)访问节点2
可见[2]=1，欧拉[1]=2
为所有未访问的相邻节点运行 dfs() (3, 4)
(3)访问节点3
可见[3]=1，欧拉[2]=3
所有相邻节点都已经访问过，返回父节点
并将父级添加到 Euler tour Euler[3]=2
(4)访问节点4
可见[4]=1，欧拉[4]=4
所有相邻节点都已经访问过，返回父节点
并将父级添加到 Euler 巡回赛，Euler[5]=2
(5)访问节点2
所有相邻节点都已经访问过，返回父节点
并将父级添加到 Euler 游览中，Euler[6]=1
(6)访问节点1
所有相邻节点都已经访问过，节点1是根节点
所以，我们在这里停止递归。
同样，例如2：

C++

// C++ program to print Euler tour of a
// tree.
#include 
using namespace std;
 
#define MAX 1001
 
// Adjacency list representation of tree
vector adj[MAX];
 
// Visited array to keep track visited
// nodes on tour
int vis[MAX];
 
// Array to store Euler Tour
int Euler[2 * MAX];
 
// Function to add edges to tree
void add_edge(int u, int v)
{
    adj[u].push_back(v);
    adj[v].push_back(u);
}
 
// Function to store Euler Tour of tree
void eulerTree(int u, int &index)
{
    vis[u] = 1;
    Euler[index++] = u;
    for (auto it : adj[u]) {
        if (!vis[it]) {
            eulerTree(it, index);
            Euler[index++] = u;
        }
    }
}
 
// Function to print Euler Tour of tree
void printEulerTour(int root, int N)
{
    int index = 0; 
    eulerTree(root, index);
    for (int i = 0; i < (2*N-1); i++)
        cout << Euler[i] << " ";
}
 
// Driver code
int main()
{
    int N = 4;
 
    add_edge(1, 2);
    add_edge(2, 3);
    add_edge(2, 4);
 
    // Consider 1 as root and print
    // Euler tour
    printEulerTour(1, N);
 
    return 0;
}

Java

// Java program to print Euler tour of a
// tree.
import java.util.*;
 
class GFG{
 
static final int MAX = 1001;
static int index = 0;
 
// Adjacency list representation of tree
static ArrayList<
       ArrayList> adj = new ArrayList<>();
 
// Visited array to keep track visited
// nodes on tour
static int vis[] = new int[MAX];
 
// Array to store Euler Tour
static int Euler[] = new int[2 * MAX];
 
// Function to add edges to tree
static void add_edge(int u, int v)
{
    adj.get(u).add(v);
    adj.get(v).add(u);
}
 
// Function to store Euler Tour of tree
static void eulerTree(int u)
{
    vis[u] = 1;
    Euler[index++] = u;
     
    for(int it : adj.get(u))
    {
        if (vis[it] == 0)
        {
            eulerTree(it);
            Euler[index++] = u;
        }
    }
}
 
// Function to print Euler Tour of tree
static void printEulerTour(int root, int N)
{
    eulerTree(root);
    for(int i = 0; i < (2 * N - 1); i++)
        System.out.print(Euler[i] + " ");
}
 
// Driver code
public static void main(String[] args)
{
    int N = 4;
     
    for(int i = 0; i <= N; i++)
        adj.add(new ArrayList<>());
         
    add_edge(1, 2);
    add_edge(2, 3);
    add_edge(2, 4);
 
    // Consider 1 as root and print
    // Euler tour
    printEulerTour(1, N);
}
}
 
// This code is contributed by jrishabh99

Javascript

 
// Javascript program to print Euler tour of a
// tree.
var MAX = 1001;
 
// Adjacency list representation of tree
var adj = Array.from(Array(MAX), () => Array());
 
// Visited array to keep track visited
// nodes on tour
var vis = Array(MAX);
 
// Array to store Euler Tour
var Euler = Array(2 * MAX);
 
// Function to add edges to tree
function add_edge(u, v)
{
    adj[u].push(v);
    adj[v].push(u);
}
 
// Function to store Euler Tour of tree
function eulerTree(u, index)
{
    vis[u] = 1;
    Euler[index++] = u;
     
    for(var it of adj[u])
    {
        if (!vis[it])
        {
            index = eulerTree(it, index);
            Euler[index++] = u;
        }
    }
    return index;
}
 
// Function to print Euler Tour of tree
function printEulerTour(root, N)
{
    var index = 0; 
    index = eulerTree(root, index);
    for(var i = 0; i < (2 * N - 1); i++)
        document.write(Euler[i] + " ");
}
 
// Driver code
var N = 4;
add_edge(1, 2);
add_edge(2, 3);
add_edge(2, 4);
 
// Consider 1 as root and print
// Euler tour
printEulerTour(1, N);
 
// This code is contributed by rrrtnx
 

输出：

1 2 3 2 4 2 1

辅助空间：O(N)
时间复杂度：O(N)