我是否正确理解此递归？

Question

Could someone please help walk me through my recursive code? Here's how I make sense of it (but I do not think I am stepping through the code correctly):

1. if ( first > last ) return -1
2. else
3. if ( result == 0 ) return last
4. else return SeqSearch (data, first, last-1, key)
5. restart the method but with last as last-1 ("keller")
6. repeat steps 1, 2, and 3
7. else return SeqSearch(data, first, last-1, key)
8. restart the method but with last as last-1 ("six")
9. etc ...

Here is my code:

public static void main (String[] args)
{
    String[] data = new String[]{"help","jackson","six","keller","mean"};
    int first = 0;
    int last = data.length-1;
    String key ="help";
    System.out.println(SeqSearch(data,first,last,key));
}
public static int SeqSearch(String[] data,int first,int last,String key)
{
    if(first > last)
        return -1;
    else{
        int result = data[last].compareTo(key);
        if(result == 0)
            return last;
        else
            return SeqSearch(data,first,last-1,key);
    }
}

Answer 1

A good way to understand a recursive function is to break it down into its base cases and recursive cases.

This SeqSearch has two base cases:

1. Not found

if (first > last)
    return -1;

2. Value found

if (data[last].compareTo(key) == 0)
    return last;

Now, that leaves the recursive cases. Here, we have only one recursive case, but there could be several.

Now, when designing a recursive function, you have to ensure that each recursive call is reduced , or simpler , than previous calls, in the sense that we're getting closer to one of the base cases each time. This is very much related to the mathematical concept of Induction .

So, each call to the recursive case must progress one "step" closer to the answer. ^* Here we see that the value of last is reduced by subtracting one, bringing it closer to zero at each step.

In turn, this means that the function is referring to a smaller and smaller subset of the data array; conceptually, this is analogous to passing a smaller array to the recursive call, which has one less element.

At this point, the base cases start to make sense:

1. When first is greater than last , we have an array with no elements: the tail of the list has overtaken its head .

2. When the search key is found, we return its index as our result.

This function is peculiar (among search functions), in that it finds the first matching index from the end of the list; a more commonplace operation is to find the first matching index from the beginning of a list.

This could be achieved by incrementing first instead of decrementing last . This would still count as a reduction --- even though it is adding --- because the recursive step is strictly smaller than the original step.

---

^* This means that each recursive call much be "simpler" than the previous one; so if you can understand the problem at any point, the next step should be simpler; the only complication is that it is nested within the original step.