How to keep track of node depth in DFS without recursion(using a stack)?

Question

This is my code snippet for DFS with out recursion in python:

 def DFS(graph,start,end):
explored=[]
queue=[[start]]

if start == end:
    return "done"
while queue:
    path=queue.pop()
    node=path[-1]
    if node not in explored:
        neighbours=graph[node]

        for neighbour in neighbours:
            new_path=list(path)
            new_path.append(neighbour.name)
            queue.append(new_path)
            if neighbour.name== end:
                return new_path
        explored.append(node)
return "no path"

This is how my node looks like: class edge: #def init():

def __init__(self,name,value,depth=0):
    self.name=name
    self.value=value
    self.depth=depth

How do I keep track of levels of each node as I've to implement depth limited search without recursion?

Answer 1

Your current algorithm has no way of counting levels since you are not keeping track of enough information in the algorithm.

As you say, keeping track of levels is far easier when doing recursion. The difference between recursion and interation is not that huge. You exchange a function call for a loop and some minor restructuring of your code to compensate for the loop.

You should still be able to figure out your current depth even if you have an iterative algorithm. If you would start with the recursive version and work your way towards an iterative solution while keeping the depth knowledge, then i think you'd solve it.

This feels like school work to me so i will not give you the solution. I hope you understand.

One hint could be to hold not only the path in your queue but also the depth, for example as a tuple.