递归函数输出错误

Question

Looking for help on a java assignment from school, I am trying to create a recursive algorithm that solves the following puzzle:

Given a starting position and an array of length n consisting n-1 positive numbers with the last position of the array being 0, for example:

{4 8 5 2 3 5 1 6 4 0}

The rules of the game:

From starting position move to right equal to the value @ starting position, repeat until you can no longer move to the right.

Once you can no longer move to the right, move left in similar fashion as you moved to the right and stop once you can no longer move to the left.

Now keep repeating this process.

The puzzle will be solved when you have moved the last position of the array holding value of 0.

Otherwise the puzzle is unsolvable.

1. In the above example if we start @ first position which is '4'
2. We move to the right 4 positions ending up @ position 5 holding value 3
3. We move to the right 3 positions ending up @ position 8 holding value 6
4. We move to the left 6 positions ending up @ position 2 holding value 8
5. We move to the right 8 positions ending up @ last position holding value 0
6. since we have moved to the last position of the array, the puzzle is solvable.

I have to solve this puzzle using recursion, I have come up with the algorithm but the output I am getting false even though the puzzle is solvable.

Here is my Algorithm:

static boolean rightWing(int[] A, int i) //i = starting position
{

    int left=i;
    int right=A.length-i-1;

    if (A[i]<right)
    {
        i=i+A[i];
        rightWing(A, i);
    }
    if (A[i]<left)
    {
        i=i-A[i];
        rightWing(A,i);
    }

    if (right==A[i])
        return true;
    else
        return false; 

}  

Answer 1

try this,

static boolean rightWing(int[] A, int i) //i = starting position
{

    int left=i;
    int right=A.length-i-1;

    if (A[i]<right)
    {
        i=i+A[i];
        return rightWing(A, i);
    }
    if (A[i]<left)
    {
        i=i-A[i];
        return rightWing(A,i);
    }

    if (right==A[i])
        return true;
    else
        return false; 
} 

Notice the return before the recursive calls to rightWing. You need this otherwise your method will always return the result of right==A[i] of the first call.