Java中的Trie上的DFS和BFS

Question

I have a Trie which looks like this:

      Root
     /    \
    b      c
   /      / \
  a      a   h
 /      /   / \
t      t   a   e
          /   /
         t   e
            / \
           r   s
          /     \
         s       e

I'm trying to implement a DFS, and BFS. The BFS works fine, using a queue:

public String breadthFirstSearch() {
    //FIFO Queue to hold nodes
    Queue<TrieNode> nodeQueue = new LinkedList<TrieNode>();

    //Output array
    ArrayList<Integer> out = new ArrayList<Integer>();

    //Start from root
    nodeQueue.add(this.root);

    //While queue is not empty
    while (nodeQueue.isEmpty() == false) {
        //Remove and return first queue element
        TrieNode current = nodeQueue.poll();
        //For node's children
        for (int i=0; i<26; i++) {
            //If not null
            if (current.offspring[i] != null) {
                //Add node to queue
                nodeQueue.add(current.offspring[i]);
                //Add node's index (char) to output array
                out.add(i);                    
            }
        }
    }
    //Return result
    return indexArrayToString(out);
}

Output:

b,c,a,a,h,t,t,a,e,t,e,r,s,s,e

Now, I'm trying to implement the DFS (same algorithm, but using a stack) however the output isn't correct:

public String depthFirstSearch() {
    //LIFO Stack to hold nodes
    Stack<TrieNode> nodeStack = new Stack<TrieNode>();

    //Output array
    ArrayList<Integer> out = new ArrayList<Integer>();

    //Start from root
    nodeStack.push(this.root);

    //While stack is not empty
    while (nodeStack.isEmpty() == false) {
        //Remove and return first stack element
        TrieNode current = nodeStack.pop();
        //For node's children
        for (int i=0; i<26; i++) {
            //If not null
            if (current.offspring[i] != null) {
                //Add node to stack
                nodeStack.push(current.offspring[i]);
                //Add node's index (char) to output array
                out.add(i);                    
            }
        }
    }
    //Return result
    return indexArrayToString(out);
}

This gives:

b,c,a,h,a,e,e,r,s,e,s,t,t,a,t

When I want it to give:

t,a,b,t,a,t,a,s,r,e,s,e,e,h,c

I can't figure out what's going wrong.

Answer 1

I have implemented the map-based approach that I mentioned in my comment, ie without modifying the original TrieNode class:

  public String depthFirstSearch() {
            //LIFO Stack to hold nodes
            Stack<TrieNode> nodeStack = new Stack<TrieNode>();
            //keep set of processed nodes (processed node is a node whose children were already pushed into the stack)
            Set<TrieNode> processed = new HashSet<TrieNode>();
            //boolean for checking presence of at least one child
            boolean hasChild=false;
            //map for trienode->char
            Map<TrieNode, Integer> map = new HashMap<TrieNode, Integer>();

            //Output array
            List<Integer> out = new ArrayList<Integer>();

            //Start from root
            nodeStack.push(this.root);

            //While stack is not empty
            while (nodeStack.isEmpty() == false) {

                //Peek at the top of stack
                TrieNode topNode = nodeStack.peek();

                //if it is not processed AND if it has at least one child, push its children into the stack from right to left. otherwise pop the stack

                hasChild=false;                
                if(!processed.contains(topNode))
                {

                   for (int i=25; i>=0; i--) 
                   {
                       //If not null
                       if (topNode.offspring[i] != null) 
                       {
                         //Add node to stack and map
                         nodeStack.push(topNode.offspring[i]);
                         map.put(topNode.offspring[i], i);
                         hasChild=true;                                               
                       }     

                   }//end for

                   processed.add(topNode); //after discovering all children, put the top into set of processed nodes

                   if(!hasChild) //top node has no children so we pop it and put into the list
                       {
                          TrieNode popNode = nodeStack.pop();
                          if(map.get(popNode)!=null)
                             out.add(map.get(popNode)); 

                       }

                }
                else //the node has been processed already so we pop it and put into the list

                {               
                    TrieNode popNode = nodeStack.pop();
                    if(map.get(popNode)!=null)
                       out.add(map.get(popNode)); 
                }


            }//end while stack not empty

            //Return result
            return indexArrayToString(out);

        }//end method

Answer 2

To get the output that you wanted, you need to think about when a node is added to the out list. In your code, you start at the root and iterate throught it's offspring in a kind-of recursive style while adding them directly to your output. Therefore your output has more in common with a BFS than a DFS.

Although there are very simple DFS implementations like

DFS(TrieNode current){ 
  for(int i = 26; i >= 0; i--){
    if(current.offspring[i] != null){
      DFS(current.offspring[i]);
    }
  }
  out.add(current);
}

if you want to keep most of your code for any reason, you could create a second stack that keeps track for you where in the tree you are and when which node is supposed to be added to the output. Explicitly, this could look something like this:

public String depthFirstSearch() {
  //LIFO Stack to hold nodes
  Stack<TrieNode> nodeStack = new Stack<TrieNode>();

  //Second stack that keeps track of visited nodes
  Stack<TrieNode> helpStack = new Stack<TrieNode>();

  //Output array
  ArrayList<Integer> out = new ArrayList<Integer>();

  //Start from root
  nodeStack.push(this.root);

  //While stack is not empty
  while (nodeStack.isEmpty() == false) {
    //Remove and return first stack element
    TrieNode current = nodeStack.peek();

    //We visited this node -> push it on the second stack
    helpStack.push(current);

    //We want to add nodes to the output once we reach a leaf node, so we need a
    //helper variable
    boolean hasOffspring = false;

    //For node's children - since we want to go the left path first we push the 
    //children in right-to-left fashion on the stack. Can vary with implementation.
    for (int i=25; i>=0; i--) {
        //If not null
        if (current.offspring[i] != null) {
            //Add node to stack
            nodeStack.push(current.offspring[i]);
            //not a leaf
            hasOffspring = true;                  
        }
     }

     //if we reached a leaf node add it and all previous nodes to the output until 
     //we reach a fork where we didn't already fo the other path
     if(!hasOffspring){
       TrieNode node1 = nodeStack.peek();
       TrieNode node2 = helpStack.peek();
       while(node1.equals(node2)){
         nodeStack.pop();
         helpStack.pop();

         //Add node's index (char) to output array
         out.add(node1);  

         //we are back at the root and completed the DFS
         if(nodeStack.isEmpty() || helpStack.isEmpty()) break;
         node1 = nodeStack.peek();
         node2 = nodeStack.peek();
       }
     }
 }
  //Return result
  return indexArrayToString(out);
}