I'm doing a project to find the Eulerian path.  Cane someone find an example where the algorithm is wrong? The function EulerianPath recursively prints the Eulerian Path.Some some parts of the code are in Portuguese.#include <bits/stdc++.h>using namespace std;class Grafo{    private:        int N,A; // N: Vertices; A: Arestas;        int graph[100][100]; // matriz do grafo        bool visited[100];    public:        Grafo(int graphsize);        int getArestas();        void setArestas(int x, int y);        bool isComplete();        int getDegree(int v);        bool isEuler();        void EulerCicle();        void setNodes(int k);        int maxArestas();        int Goodman();        void DFS(int);        void BFS(int);        /* Dijkstra */        int minDistance( int*, bool* );        int printSolution(int dist[], int n, int parent[], int i, int src);        void Dijkstra( int, int );        void printPath(int parent[], int j);        /**/        void EulerianPath( int src );};Grafo::Grafo(int graphsize){    N = graphsize;    memset(graph, 0, sizeof(graph));    memset(visited, false, sizeof(visited));}int Grafo::getArestas(){    return 0;}void Grafo::setNodes(int k){        N = k;}void Grafo::setArestas(int x, int y){        graph[x-1][y-1] = 1;        A++;}int Grafo::maxArestas(){    return ((N*(N-1))/ 2);}int Grafo::getDegree(int v){        int aux = 0;        for(int i = 0; i < N; i++){            if(graph[i][v] == 1){                aux++;            }        }        for(int j = 0; j < N; j++){            if(graph[v][j] == 1){                aux++;            }        }    return aux/2;}bool Grafo::isComplete(){    if( A == maxArestas())        return true;    return false;}bool Grafo::isEuler(){    bool aux = true;    for(int i = 0; i < N; i++){        if(getDegree(i) % 2 != 0)        {            aux = false;            break;        }    }    return aux;}void Grafo::DFS( int actual ){    visited[actual] = true;    for( int i = 0; i < N; i++ )    {        if( graph[actual][i] == 1 )        {            if( !visited[i] )            {                DFS( i );            }        }    }}void Grafo::BFS( int s ){    queue<int> Q;    visited[s] = true;    Q.push(s);    while( !Q.empty() )    {        s = Q.front();        cout << s+1 <<  ;        Q.pop();        for( int i = 0; i < N; i++ )        {            if( !visited[i] && graph[i][s] == 1 )            {                //cout << here << endl;                visited[i] = true;                Q.push(i);            }        }    }}int Grafo::Goodman( ){    int cont = 0;    for( int i = 0; i < N; i++ ){        if( !visited[i] ){            DFS( i );            cont++;        }    }    return cont;}/* Dijkstra */int Grafo::minDistance(int dist[], bool sptSet[]){   // Initialize min value   int min = INT_MAX, min_index;   for (int v = 0; v < N; v++)     if (sptSet[v] == false && dist[v] <= min)         min = dist[v], min_index = v;   return min_index;}//void Grafo::printPath(int parent[], int j ){    // Base Case : If j is source    if (parent[j]==-1)        return;    printPath(parent, parent[j]);    printf(%d , j);}// A utility function to print the constructed distance arrayint Grafo::printSolution(int dist[], int n, int parent[], int i, int src ){    printf(Vertex\t  Distance\tPath);//    for (int i = 1; i < N; i++)//    {          cout << endl << src <<  ->  << i <<  \t\t  << dist[i] << \t << src << endl;        printPath(parent, i );//    }}void Grafo::Dijkstra( int src, int target ){     int distancia[N];     // The output array.  distancia[i] will hold the shortest                      // distanciaance from src to i     bool sptSet[N]; // sptSet[i] will true if Nertex i is included in shortest                     // path tree or shortest distanciaance from src to i is finalized     int parent[N];     // Initialize all distances as INFINITE and stpSet[] as false     for (int i = 0; i < N; i++)        distancia[i] = INT_MAX, sptSet[i] = false, parent[src] = -1;     // Distance of source vertex from itself is always 0     distancia[src] = 0;     // Find shortest path for all vertices     for (int counter = 0; counter < N-1; counter++)     {       // Pick the minimum distance vertex from the set of vertices not       // yet processed. u is always equal to src in first iteration.       int u = minDistance(distancia, sptSet);       // Mark the picked vertex as processed       sptSet[u] = true;       // Update distancia value of the adjacent vertices of the picked vertex.       for (int v = 0; v < N; v++)         // Update distancia[v] only if is not in sptSet, there is an edge from         // u to v, and total weight of path from src to  v through u is         // smaller than current value of distancia[v]         if (!sptSet[v] && graph[u][v] && distancia[u] != INT_MAX                                       && distancia[u]+graph[u][v] < distancia[v])         {            parent[v] = u;            distancia[v] = distancia[u] + graph[u][v];         }     }     // print the constructed distance array     printSolution(distancia, N, parent, target, src );}/* Dijkstra FIM */void Grafo::EulerianPath( int src ){      for (int i = 0; i < N; ++i)    {        if( graph[src][i] != 0 )        {            graph[src][i] = 0;            graph[i][src] = 0;            EulerianPath( i );        }    }    cout << src+1 << endl;}int main(){    int x, y, k;    cin >> k;    Grafo G(k);    while(cin >> x >> y && x != 0 && y != 0 ){        G.setArestas(x,y);        G.setArestas(y,x);    }    if( G.isEuler() )        G.EulerianPath( 0 );    return 0;}
Eulerian Path algorithm
c++;algorithm;c++11;graph