How can I stop a recursive call?

Question

Or is that possible? That is, can I stop the recursion before the stack is empty?
I am trying to test for cycles in a graph, and print out only the edges which make up the cycle in the graph using depth first search. Or perhaps someone has some better ideas of how to do this, without attempting to do that clumsy "stop a recursive call" method?
To explain what I was thinking of: Go trough edges until a visited one is encountered (x). Then return back and terminate when we are back in that (x) edge. The (x) edge has a lable from the edge which called the dfs on the (x) edge, so that (x) is included in the cycle.
tnx in advance!

Answer 1

Or is that possible? That is, can I stop the
recursion before the stack is empty? You can stop recursion whenever you want merely by not doing the recursive call when some condition holds. (Obviously.)
For 'find a cycle', you want to keep the search going until a cycle is found, and then collect the path on the return trip.
Here's a simple example:
Assuming a Node class
class Node {
   public List<Node> children=new ArrayList();
   public boolean visited=false;
   public Node() {
}this code will return a list of nodes on the cyclic path (plus the path from root to the start of the cycle):
  /** returns a node path ending with a cycle, or an empty list if no cycle found */
  List getCycle(Node root) {
    List cycle=new ArrayList();
    findCycle(root, cycle);
    return cycle;
  /** returns true if cycle was found, puts the path in the 'path' argument */
  boolean findCycle(Node n, List path) {
    if (n.visited) { // recursion bottom: cycle found
      path.add(n); // add first element to path
      return true; // terminate recursion
    // base case
    n.visited=true;
    for (Node ch : n.children) { // iterate over children
      // depth-first recursion. returns true if cycle is found through child 'ch'
      if (findCycle(ch, path)) { 
        // if there is a cyclic path going through ch,
        // the path also goes through n
        path.add(n); 
        return true; // terminate recursion
    return false; // no cycle through n
  }This example returns the first cycle found, you may want to return all cycles, the shortest cycle or some variant thereof.
You would probably want to get rid of the path before the start of the cycle.
And by using the method call stack, the longest (non-cyclic) path in the graph cannot be longer than the maximum size of the call stack.
So 'stopping a recursive call' need not be that clumsy. Although it can be tricky to get all the details right, especially at first.