如何递归地在链表中找到最大值？

Question

I need to find the maximum value in a linked list given the head of the list as a parameter recursively. I have no clue how to start the recursive part of the method. This is all I have so far.

int maxOfList(List M){  
    List max = M;
    if(M == null)
        return max;
    if(M.next > max){
        max = M.restOfTheInts;
        return maxOfList();
    }
}

Answer 1

In recursion, you often need an entry method and a worker method. The entry method is the special case that allows the worker method to work in all cases, and the worker does the recursion.

For example, your worker might be something like:

int maxOfList(int currentMax, List<int> listToCheck) {
  // Nothing to compare? currentMax is it!
  if (listToCheck == null || listToCheck.size() == 0) return currentMax;

  // Compare and return.
  List<int> restOfList = listToCheck.subList(1, listToCheck.size());
  return maxOfList(Math.max(currentMax, listToCheck.get(0)), restOfList);
}

And then to kick that off, you need your entry method:

int maxOfList(List<int> listToCheck) {
  return maxOfList(Integer.MIN_VALUE, listToCheck);
}

Answer 2

So, for recursion to effectively work, you need to have the whole context visible inside the function.

int maxOfList(List m) {
     if(m.next == null)
          return m;
     int previousMax = maxOfList(m.next);
     if(m > previousMax)
          return m;
     else
          return previousMax;
}

Answer 3

int maxValue(List m){
   return maxValue(m, Integer.MIN_VALUE);
}

int maxValue(List m, int num){
  if(m.next == null){
     if(m.data > num)
     return num = m.data;
  }
  return maxValue(m.next, num);
}

Answer 4

This should be pretty straightforward. In order to achieve a recursive solution, think about all these steps:

• What's the recursive idea? The maximum of a list {L} is the max(Li, {L} - Li) , where Li is the current element;
• What's the stop condition? We know that if a list is empty, the maximum could be something that any number will be greater, let's say MIN_INT ;
• Putting all together: So, at the end we could say that a pseudo-code would look like this:

int maxOfList(List M) { if(M == null) return Integer.MIN_VALUE; int max = maxOfList(M.next); return M.value > max ? M.value : max; }

I am supposing that the linked list has its content in value and points to next element in next (tail pointing to null ). If you find any further problems, take a look at this posts:

Finding Max value in an array using recursion

Python: Recursive function to find the largest number in the list