Рекурсивная программа SCC Kosaraju автоматически завершается при выполнении на больших входах

Question

Я пытаюсь реализовать Алгоритм сильной связи Косараю с использованием рекурсивного подхода в C ++ . В то время как программа отлично работает на небольших графах , но останавливает промежуточное выполнение при выполнении шага ранжирования узлов алгоритма на больших графах, имеющих 875714 узлов .

Функция, вызывающая проблему: Graph :: fillOrder (int v, bool посещения [], стек и стек)

Ссылка на файл: Ссылка на файл: https://drive.google.com/file/d/1aL19d6FCTT9vW70jBGyH-r7MpOOQ7gyz/view?usp=sharing

Я прошел через сеть, чтобы найти возможное решение, но не смог найти. Хотя существует несколько нерекурсивных подходов, предполагающих, что рекурсивные подходы решают проблему переполнения стека, я хочу знать, если это так, есть ли способ ее решить?

#include<iostream>
#include<list>
#include<stack>
#include<fstream>

using namespace std;

class Graph{
    int V;
    list<int> *adj;

    void fillOrder(int v, bool visited[], stack<int> &stack);
    void DFSUtil(int v, bool visited[], int &count);

public:
    Graph(int V);
    void addEdge(int v, int w);
    void printSCCs();
    Graph getTranspose();
};

Graph::Graph(int V){
    this->V = V;
    adj = new list<int>[V];
}

void Graph::DFSUtil(int v, bool visited[], int &count){
    visited[v] = true;
    count++;
    list<int>::iterator it;
    for(it = adj[v].begin(); it!=adj[v].end(); it++){
        if(!visited[*it])
            DFSUtil(*it, visited, count);
    }
}

Graph Graph::getTranspose(){
    Graph g(V);
    for(int v=0; v<V; v++){
        list<int>::iterator it;
        for(it=adj[v].begin(); it!=adj[v].end(); it++){
            g.adj[*it].push_back(v);
        }
    }
    return g;
}

//add edge to graph
void Graph::addEdge(int v, int w){
    adj[v].push_back(w);
}

//node ranking function
void Graph::fillOrder(int v, bool visited[], stack<int> &Stack){
    visited[v] = true;

    list<int> :: iterator it;
    for(it=adj[v].begin(); it!=adj[v].end(); it++){
        if(!visited[*it])
            fillOrder(*it, visited, Stack);
    }

    Stack.push(v);
}

//print SCCs
void Graph::printSCCs(){
    stack<int> Stack;

    //keeping track of nodes visited
    bool *visited = new bool[V];
    for(int i=0; i<V; i++){
        visited[i]=false;
    }

    //node ranking
    for(int i=0; i<V; i++){
        cout<<i<<" ";
        if(visited[i]==false){
            fillOrder(i, visited, Stack);
        }
    }

    //computing transpose of the graph
    Graph gr = getTranspose();

    //reseting visited values for every node to false
    for(int i=0; i<V; i++){
        visited[i]=false;
    }
    int max_count=0;
    while(Stack.empty()==false){
        int v = Stack.top();
        Stack.pop();

        if(visited[v]==false){
            int count=0;
            gr.DFSUtil(v, visited, count);
            if(count>max_count){
                max_count = count;
                cout<<"\nMax count: "<<max_count;
            }
        }
    }
}

int main() 
{       
    Graph g(875714);

    ifstream file;
    file.open("SCC.txt");
    int s, e;
    while(file>>s>>e){
        //eleminating self loops
        if(s==e)
            continue;
        else
            g.addEdge((s-1), (e-1)); //for files containing nodes from 1
    }
    cout << "Following are strongly connected components in "
            "given graph \n"; 
    g.printSCCs();

    return 0; 
} 

Ожидаемый результат: размер отпечатка каждого сильно связанного компонента на графике

Фактический результат: завершение при выполнении без завершения всей программы