Finding a non-recursive algorithm

Question

I had a project a year ago that was supposed to teach the class recursion. Already being familiar with the Java language, the project was simple.
The project was, you ahve a "cleaning robot" which cleans an entire room and then returns to the spot it originally was. The room was inputed as a txt file. Everytime you moved to a spot it was automatically cleaned
The Robot was given to you. The robot class hasthe following methods:
void move(Direction)   - moves in the direction you gave it.
boolean canMove(Direction)    -  returns true if the robot can move there without running into a wall
boolean hasBeen(Direction) - returns true if the robot has cleaned the spot that is in that directionThe Direction class was given to you. It is an enumerated type with the Directions FORWARD, BACWARD, LEFT, RIGHT.
now the Recursive algorithm is simple:
private void clean(Direction c, Direction r)
             move(c); //clean spot in direction
             for(Direction d : Direction.values()) //go every direction
                  if(canMove(d) && !haveBeen(d)) clean(d,reverse(d));
             move(r); //go back way we came
private Direction reverse(Direction d)
               switch(d)
                  case FORWARD:  d = Direction.BACKWARD; break;
                  case RIGHT:    d = Direction.LEFT;     break;
                  case BACKWARD: d = Direction.FORWARD;  break;
                  case LEFT:     d = Direction.RIGHT;    break;
             return d;     
public void start()
         clean(Direction.FORWARD, Direction.BACKWARD);
    }But I am curious how someone would go about implementing a NON recursive algorithm. I understand it would probably be around 2000 lines to implement it. I am not asking anyone to implement it, nor do I plan on it (well..I may one day if I am bored) I am only asking for mere curiosity how someone would go about implementing this non-recursively.
I have thought about it and thought about it, and the only thing I come up with is recursion. What are your thoughts?

Answer 1

then I think it'll work.Almost. Your algorithm is flawed in this section:
move(c);
      // After everything else, come back.
       backtrace.push(reverse(c));What happens when c is the reverse direction? You add to the stack the reverse of the reverse. This means you will continually go back and forth in an infinite loop. I took what you started with and worked it into a working solution:
private void cleanAll() {
          //imitate the call stack
          Stack<Stack<Direction>> call = new Stack<Stack<Direction>>();
          //holds all the reverse directions     
         Stack<Direction> backtrack = new Stack<Direction>();
         //starting stack
         Stack<Direction> start = new Stack<Direction>();
         //load the starting stack
         for (Direction d : Direction.values())
              if(canMove(d) && !haveBeen(d))
                   start.push(d);
         call.push(start);
         while (!call.isEmpty()) {
              Stack<Direction> s = call.pop();
              while(!s.isEmpty()){
                   Direction c = s.pop();
                  move(c); //clean in this direction
                  backtrack.push(reverse(c)); //record the reverse
                  Stack<Direction> temp = new Stack<Direction>();
                  call.push(s); //stop the current path
                  //load the new stack
                  for (Direction d : Direction.values())
                     if (canMove(d) && !haveBeen(d))
                          temp.push(d);
                 if(!temp.isEmpty())   
                      s = temp; //make temp the current stack
         if(!backtrack.isEmpty())
              move(backtrack.pop());// After everything else, come back.
    }The problem with your solution is that you use 1 stack for the entire process. In this case, it does not differentiate between moves, so it doesn't KNOW what is a reverse. You need to seperate the reverse directions and treat the different in the special case. In order to do that, you need to know WHEN to reverse. Well you reverse when you have completed a cleaning "path".
My algorithm implements that "path" as another stack. And adds it to a stack of stacks. What this does is it allows me to know when to reverse. I pop off a stack from the call stack, and then after I am done with that stack I have to reverse, as shown in the code I posted.
Thank you so much for enhancing my knowledge of Stacks. You have helped emensely. I will be sure to tell my professor that i implemented a iterative solution in about 50 lines of code (extremely lower than the 2000 he hypothosized)