Compare elements in an array of string in Java

I have to write a method that will compare elements in an array of strings and return the index of the largest element. It's going to be done recursively using a divide and conquer approach. I have an idea, and I was just looking to see if my idea was right or if it should be done in a different way.

I was planning on looking at the array from the left side to mid -1, then look at mid, and then look at mid +1 to right. I have a variable that will keep track of the largest index, and then after that make the recursive call for开发者_如何学编程 the left side and the right side.

Does that sound like a good way to approach this problem?

This is what I have so far:

public int longest()
{
    longest(0, a.length-1);
    return longestIndex;
}

private int longest( int left, int right)
{
    int longestIndex;
    int mid;

    if(left > right)
    {
        longestIndex = -1;
    }
    else if(left == right)
    {
        longestIndex = 0;
    }

    else
    {
        longestIndex = 0;

        mid = (left + right) / 2;
        longest(left, mid - 1);
        if (a[mid].compareTo(a[longestIndex]) > 0)
        {
            longestIndex = mid;
        }
        longest(mid + 1, right);            
    }            
    return longestIndex;
}

Also, since the methods are supposed to return an int, how would I pass the longestIndex n the private method up to the public method so that it would show up in my test program when longest is called?

Does it have to be recursive? Using recursion for this sounds like a case of:

And your recursion looks totally wrong anyways, because not only you are not keeping track of the actual index but also your base cases and recursive calls don't make any sense.

If I were compelled to use recursion, I would do something like:

int longest(array):
    return longest_helper(0, 0, array)

int longest_helper(max_index, curr_idx, array):
    # base case: reached the end of array
    if curr_idx == array.length:
        return max_index

    if array[curr_idx].length > array[max_index].length:
        max_index = curr_idx

    # recursive call
    return longest_helper(max_index, curr_idx + 1, array)

And then I would proceed to drop the class and tell the professor to give students problems where recursion is actually helpful next time around.

Since it doesn't look like the array is sorted, the easiest (and fastest) way to do this would just be go through the whole thing (pseudocode):

max_index  = 0
max_length = array[0].length

for index in 1 .. array.length:
    if array[index].length > max_length:
        max_length = array[index].length
        max_index  = index

return max_index

This is your fourth question in two days on recursion. It is good that you are putting homework tag but your time would be better spent understanding how recursion works.

My recommendation is to take a few colored discs (poker chips or playing cards of a single suite work well), work out manually the recursive solution to Towers of Hanoi and then come back and look at the individual questions you have been asking.

In all likelihood you will be able to answer all the questions yourself. You would also be able to accept the answers, increasing you chances in future of getting responses when you face tougher questions.