Реализовать граф из списка смежности в список Edge с помощью DFS C++

У меня есть текстовый файл, содержащий список смежности неориентированного графа, например:
1 2 3
2 1 3 4
3 1 2 4
4 2 3
Я читаю файл и сохраняю их в списке смежности,
я хочу передать эти данные в список ребер,
я пытаюсь найти все уникальные пары ребер,
используя DFS, я получаю пары, но те не уникальны,
Я пытаюсь удалить повторяющиеся пары (повторяющаяся пара ‹1,2> такая же, как ‹2,1>), но это не происходит......
< br> Вот результат, который я получаю:

степень 1: 2
Количество вершин: 4
Количество ребер: 5
Максимальная степень: 3
> Минимальная степень: 2
Список ребер: ..........

1 2
Край 1 2 Вставлен
Назад : 2 1
Край 2 1 Вставлен

2 3
Край 2 3 Вставлен
Назад : 3 1
Край 3 1 Вставлен
Назад : 3 2
Край 3 2 Вставлен

3 4
Край 3 4 Вставлено
Назад : 4 2
Край 4 2 Вставлено
Назад : 4 3
Край 4 3 Вставлено
Назад : 2 4
Край 2 4 Вставлено
Назад : 1 3
Край 1 3 Вставлено

Спасибо... Извините за длинный код........

#include <iostream>
#include <fstream>
#include <limits>
#include <vector>
#include <list>
#include <string>  
#include <sstream>
#include <cstdlib>
#include <map>

using namespace std;

typedef struct EdgeList
{
    int u;
    int v;
}EdgeList;


class Graph
{
    public:
        vector<list<int> > adj;
        int V;
        int E;

        EdgeList *edges;

        Graph(int N):adj(N+1)
        {
            V = N;
        }
        Graph(int N, int M):adj(N+1)
        {
            V = N; 
            E = M; 
            int x = E+550;
            edges = new EdgeList[x];
        }

        void addEdgeList(Graph g, int u, int v);
        bool ischeckEdge(Graph g,int u,int v);

        void addEdge(int u, int v);
        void deleteSelfLoops(Graph g);

        int degree(Graph g, int v);
        int maxDegree(Graph g);
        int minDegree(Graph g);
        int edgeCount(Graph g);
        int numberOfSelfLoops(Graph g); 

        bool isEdge(Graph g, int u,int v);

        void DFS(Graph g);
        void dfsUtil(Graph g, int v, bool visited[] );              
};

int e = 0;
void Graph::addEdgeList(Graph g, int u, int v)
{
    if(ischeckEdge(g,u,v))
    {
        cout<<"Edge "<<u<<" "<<v<<" Inserted "<<endl;
        g.edges[e].u = u;
        g.edges[e].v = v;
        e++;
    }
}

bool Graph::ischeckEdge(Graph g, int u, int v)
{
    bool a,b,c,d;


    for(int i=0;i<=g.E; i++)
    {

        if( ((g.edges[i].u == u || g.edges[i].v == v) && (!g.edges[i].u == u || !g.edges[i].v == v)) )
        {
            cout<<"First block" ;
            return false;

        }
        else if( ((g.edges[i].u == v || g.edges[i].v == u) && (!g.edges[i].u == v || !g.edges[i].v == u)))
        {
            cout<<" sec block";
            return false;
        }
        else 
        {
            return true;
        }
    }
}


void Graph::dfsUtil(Graph g, int v, bool visited[])
{
    list<int> temp;
    temp  = g.adj[v];

    if(!visited[v])
    {
         visited[v] = true; 
    }

    list<int>::iterator j;
    for(j = temp.begin();j != temp.end(); j++)
    {
        if(!visited[*j])
        {
            cout<<endl<<v<<" "<<*j<<endl;// print edges
            g.addEdgeList(g,v,*j);
            dfsUtil(g, *j, visited);
        }
        else //back edge
        {
            cout<<" Back : "<<v<<" "<<*j<<endl;
            g.addEdgeList(g,v,*j);
        }
    }   
}

void Graph::DFS(Graph g)
{
    bool *visited = new bool[g.V+1];
    int *parent = new int[g.V+1];

    for(int i = 0; i <= g.V; i++)
    {
         visited[i] = false;
         parent[i] = -1;
    }

    for(int v = 0; v <= g.V; v++)
    {
        if(!visited[v])
        {
            dfsUtil(g, v , visited);
        }
    }
 }

 bool Graph::isEdge(Graph g, int u, int v)
 {
     for(int w : adj[v])
     {
        if(u == w)
        {
            return true;
        }
     }
    return false;
 }


void Graph::addEdge(int u, int v)
{
    adj[u].push_back(v); //undirected graph
    //adj[v].push_back(u);
}

void Graph::deleteSelfLoops(Graph g)
{
    for(int v = 0; v <= g.V; v++)
   {
        for(int w : g.adj[v])
        {
            if(v == w)
            {
                g,adj[v].remove(w);
            }
       }
    }
}

int Graph::degree(Graph g, int v)
{
     int deg = 0;

    for(int i = 0;i < g.adj[v].size();i++)
    {
        deg++;
    }   
    return deg;
}

int Graph::edgeCount(Graph g)
{
    int edge = 0;
    int i;

    if(g.adj[0].empty())
    {
         i = 1;
    }
    else
    {
        i = 0;
    }

    for(i; i <= g.V; i++)
    {
        edge = edge + degree(g,i);
    }

   return edge/2; //handshaking lemma
}

int Graph::maxDegree(Graph g)
{
    int max = 0;

    for(int i = 0; i <= g.V; i++)
    {
        if(degree(g,i) > max)
        {
            max = degree(g,i);
        }
    }
    return max;
 }

int Graph::minDegree(Graph g)
{
    int min = g.V;
    int i;

    if(g.adj[0].empty())
    {
        i = 1;
    }
    else
    {
        i = 0;
    }

    for(i; i <= g.V; i++)
    {
        if(degree(g,i) < min)
        {
            min = degree(g,i);
        }
    }
    return min;
}

int Graph::numberOfSelfLoops(Graph g)
{
    int count = 0;

    for(int v = 0; v <= g.V; v++)
    {
        for(int w : g.adj[v])
        {
            if(v == w)
            {
                count++;
            }
        }
    }

    return count / 2;
 }



int main()
{
    ifstream fin("AdjList.txt");

    int V = 0;

    string str;

    while(getline(fin, str)) 
    {
    istringstream ss(str);
    int num;

    while(ss >> num)
    {
        // ... you now get a number ...
        int u;
        u = str[0] - '0'; //char can be coverted to int
        if(num != u )
        {
             //cout<<u<< "  "<< num<<endl;

        }
    }
    V++;
}
fin.close();

Graph g1(V);

fin.open("AdjList.txt");
while(getline(fin, str)) 
{
    istringstream ss(str);
    int num;

    while(ss >> num)
    {
        // ... you now get a number ...
        int u;
        u = str[0] - '0'; //char can be coverted to int
        if(num != u )
        {
             g1.addEdge(u,num);
             //cout<<u<< "  "<< num<<endl;

            }
        }
    }
    fin.close();

    Graph g(V,g1.edgeCount(g1));
    g.adj = g1.adj;

    cout<<"degree of 1 is : "<<g.degree(g,1)<<endl;
    cout<<"Nember of vertices is :"<<g.V<<endl;
    cout<<"Numbe rof edges is : "<< g.edgeCount(g)<<endl;
    cout<<"Max degree is : "<<g.maxDegree(g)<<endl;
    cout<<"Min degree is : "<<g.minDegree(g)<<endl;

    cout<<"List of edges : .........."<<endl;

    cout<< g.edges[4].u;

    for(int i=0; i<=g.E+500;i++)
    {
        g.edges[i].u=0;
        g.edges[i].v =0;
    }

    g.DFS(g); 


    return 0;
 }