Finding cycles in an undirected graph.

Question

I've been trying to implement my own graph class, and one of the things I would like to do is do a DFS to find cycles.
So far I've been able to write this and I'm pretty confident it works:
     static boolean findCycle(){
          LinkedList<Node> queue = new LinkedList<Node>();
          unEnqueue();
          Node start = graph.getFirst();
          start.visited = true;
          queue.push(start);
          Node previous = new Node();
          previous = start;
          while (!queue.isEmpty()) {
               Node node = queue.pop();
               node.visited = true;
               System.out.println("previous is "  +previous);
               for (Node neighbor : node.neighbours) {
                    if(!neighbor.visited){
                         queue.push(neighbor);
                    }else if(allVisited()){
                         return true;
                    }else if (neighbor.visited && neighbor == start){
                         unVisit();
                    }else if(neighbor.visited && neighbor != previous){
                         System.out.println("neighbor is "+ neighbor);
                         return true;
               previous = node;
               System.out.println("previous is " +previous);
          return false;
     }Visited is just a boolean value each node has.
unVisit takes our graph and resets all visited values to false.
After this returns I check each node and list those that are visited - these nodes constitute my cycle.
This returns the nodes out of order (not in the order they are listed) which is fine.
It also breaks if there is no cycle in the graph.
Can anyone think of how to correctly return false? Or, maybe a graph that would break this?
Thanks

Answer 1

Thanks for the reply. I've found some inputs where my algorithm doesn't work so I suppose I should back up and ask a new question:
Is it possible to do a DFS iteratively like I am, find the path of nodes that represents a cycle and then return that? The main problem I run into when doing these sorts of things is that since the graph is undirected the DFS likes to yield cycles of the first two nodes that are connected. Another issue is that since I only have the nodes and their neighbors there really aren't edges to iterate through and mark as back, cross etc. Is it possible to use a hashmap to store the path?
Let me know if I need to clarify things further
Also: I didn't return a cycle before because the cycle was represented as all nodes that had their boolean visited set to true. I could print the list simply by iterating through the graph and printing which nodes had a true visited boolean.
Edited by: Blitzkev on May 17, 2010 6:24 PM
Edited by: Blitzkev on May 17, 2010 6:27 PM
static LinkedList<Node> findCycle(LinkedList<Node> g){
          Stack<Node> s = new Stack<Node>();
          HashMap<Node,Node> hm = new HashMap<Node,Node>();
          LinkedList<Node> cycle = new LinkedList<Node>();
          boolean done = false;
          unMark(g);
          unVisit(g);
          s.push(g.getFirst());
          Node currNode = null;
          while (!s.isEmpty() && !done) {
               currNode = s.pop();
               currNode.visited = true;
               for (Node neighbor : currNode.neighbours) {
                    if( !neighbor.visited && neighbor.marked == 1 ) {
                         hm.put(neighbor, currNode);
                         Node n = neighbor;
                         do {
                              cycle.add(n);
                         } while( (n = hm.get(n)) != neighbor && !cycle.contains(n) && n != null );
                         done = true;
                         break;
                    if( !neighbor.visited ) {
                         s.push(neighbor);
                         neighbor.marked = 1;
                    hm.put(neighbor, currNode);
          return cycle;
     }I got it working with a hashmap.
Edited by: Blitzkev on May 17, 2010 6:48 PM