Реализация функции рекурсии C ++ в графе

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

Код здесь следующий:

if(graph.gate_list.at(check).OutEdgeCount()>1) //Suppose a node has more than one output   edge, then we need to find the maximum delay for that node before moving upwards
{
p_edge_check=p_edge;
p_edge= graph.gate_list.at(check).first_out_edge;
stack<Edge<delay_type, error_type>* > keep_edge, keep_edge1;
for(int index=0; index<11; index++)
{
for(int j=0; j< 10; j++)
{
gate_stack_temp.push_back(temp2);
}
while(!keep_edge1.empty())
{
p_edge= keep_edge1.top();
p_edge->active=true;
keep_edge1.pop();
}
delay_gate[path_index][index] = /*delay_gate[path_index][index] +*/ Recursion_Loop(graph,gate_stack_temp, p_edge, keep_edge, keep_edge1, delay_temp, index);

gate_stack[index][path_index].assign(gate_stack_temp[0].front(), gate_stack_temp[0].back());

gate_stack_temp.clear();
p_edge=p_edge_check;
for(int i=0; i<delay_temp.size(); i++)
{
delay_temp[i]=0;
}
}
while(!keep_edge1.empty())
{
keep_edge1.pop();
}
p_edge=p_edge_check;
}

Выше был код, где я вызываю рекурсивную функцию с именем Recursion Loop. Ниже я прилагаю реальную функцию рекурсии

double Recursion_Loop(Graph<delay_type, error_type, power_type, mask_type> &graph, vector<vector<int> > &gate_stack_temp, Edge<delay_type, error_type> *p_edge,  stack<Edge<delay_type, error_type>* > &keep_edge, stack<Edge<delay_type, error_type>* > &keep_edge1, vector<double> &delay_temp, int index)
{
Edge<delay_type, error_type> *p_edge_temp, *p_edge_check;
if(!FindPathLoop1(keep_edge,p_edge))
{
keep_edge.push(p_edge);
}
if(!FindPathLoop1(keep_edge1,p_edge))
{
keep_edge1.push(p_edge);
}
int temp_path = 0;

while(p_edge!=NULL)
{
if(graph.gate_list.at(p_edge->head_index).OutEdgeCount() > 0)
{
p_edge= graph.gate_list.at(p_edge->head_index).first_out_edge;
if(FindPathLoop2(gate_stack_temp,p_edge->head_index,temp_path))
{
p_edge=p_edge->same_tail_next;
if(p_edge==NULL)
{
goto point1;
}
/*if(graph.gate_list.at(p_edge->head_index).OutEdgeCount() < 0)
p_edge_temp = p_edge->same_tail_next;
if(p_edge_temp==NULL)
return graph.gate_list.at(p_edge->head_index).delay.at(index) + p_edge->delay;
else p_edge= p_edge_temp;
if(!p_edge->active) return graph.gate_list.at(p_edge->head_index).delay.at(index) + p_edge->delay;
*/

if(!FindPathLoop1(keep_edge1,p_edge))
{
keep_edge1.push(p_edge);
}
p_edge->active=false;
delay_temp[temp_path] = delay_temp[temp_path] + p_edge->delay + graph.gate_list.at(p_edge->tail_index).delay.at(index)+ Recursion_Loop(graph, gate_stack_temp, p_edge, keep_edge, keep_edge1, delay_temp, index);
p_edge= keep_edge.top();
keep_edge.pop();
gate_stack_temp[temp_path].push_back(p_edge->head_index);
}
else
{
if(!FindPathLoop1(keep_edge1,p_edge))
{
keep_edge1.push(p_edge);
}
p_edge->active=false;
if(graph.gate_list.at(p_edge->head_index).OutEdgeCount() ==0 )
{
if(FindPathLoop2(gate_stack_temp,p_edge->head_index,temp_path))
{
gate_stack_temp[temp_path].push_back(p_edge->head_index);
}
return (p_edge->delay + graph.gate_list.at(p_edge->head_index).delay.at(index));
}
else
{
return 0;
}
}
p_edge= p_edge->same_tail_next;
if(delay_temp[temp_path] > delay_temp[0])
{
delay_temp[0]= delay_temp[temp_path];
while(!gate_stack_temp[0].empty())
{
gate_stack_temp[0].pop_back();
}
while(!gate_stack_temp[temp_path].empty())
{
gate_stack_temp[0].push_back(gate_stack_temp[temp_path].back());
gate_stack_temp[temp_path].pop_back();
}
}
else if(temp_path!=0)
{
while(!gate_stack_temp[temp_path].empty())
{
gate_stack_temp[temp_path].pop_back();
}
}
temp_path++;
}
/*if(delay_temp[0] > delay_temp[temp_path])
{
delay_temp[0]= delay_temp[temp_path];
while(!gate_stack_temp[0].empty())
gate_stack_temp[0].pop_back();
while(!gate_stack_temp[temp_path].empty())
{
gate_stack_temp[0].push_back(gate_stack_temp[temp_path].back());
gate_stack_temp[temp_path].pop_back();
}
}*/

point1:
вернуть delay_temp [0];
}

Так как я новичок в C ++ (и в теории графов, где раньше были только базовые знания C), я считаю, что, возможно, мой подход здесь затрудняет вывод. Я был бы очень рад, если бы кто-то мог взглянуть на этот код. Я был на этом в течение нескольких недель без какого-либо результата и, следовательно, должен был обратиться за помощью сейчас.

Редактировать: вот функции FindPathLoop, которые также были вызваны

    bool FindPathLoop(vector<vector<vector<int> > > &gate_stack, int gate_index, int path_index)
{
vector<int> temp;

while(!gate_stack[0][path_index].empty())
{
if(gate_index == gate_stack[0][path_index].back())
{
while(!temp.empty())
{
gate_stack[0][path_index].push_back(temp.back());
temp.pop_back();
}
return true;
}
temp.push_back(gate_stack[0][path_index].back());
gate_stack[0][path_index].pop_back();
}

while(!temp.empty())
{
gate_stack[0][path_index].push_back(temp.back());
temp.pop_back();
}
return false;
}

bool FindPathLoop1(stack<Edge<delay_type, error_type>* > &keep_edge, Edge<delay_type, error_type> *p_edge)
{
stack<Edge<delay_type, error_type>* > temp;
while(!keep_edge.empty())
{
if(p_edge == keep_edge.top())
{
while(!temp.empty())
{
keep_edge.push(temp.top());
temp.pop();
}
return true;
}
temp.push(keep_edge.top());
keep_edge.pop();
}
while(!temp.empty())
{
keep_edge.push(temp.top());
temp.pop();
}
return false;
}

bool FindPathLoop2(vector<vector<int> > &gate_stack, int gate_index, int path_index)
{
vector<int> temp;

while(!gate_stack[path_index].empty())
{
if(gate_index == gate_stack[path_index].back())
{
while(!temp.empty())
{
gate_stack[path_index].push_back(temp.back());
temp.pop_back();
}
return true;
}
temp.push_back(gate_stack[path_index].back());
gate_stack[path_index].pop_back();
}

while(!temp.empty())
{
gate_stack[path_index].push_back(temp.back());
temp.pop_back();
}
return false;
}