使用递归和无循环查找嵌套列表python的最小最大值

Question

def min_max(L):

    if len(L) == 1:
        res = [L[0], L[0]]

    else:
        res = min_max(L[1:])

        if (L[0] < res[0]):
            res[0] = L[0]

        if (L[0] > res[1]):
            res[1] = L[0]

    return res

Here is my code that works for regular lists. If there is only one element, that element is both the min and the max. Otherwise, we find the min and max for the elements in the list ahead of it, and then we compare, and swap if bigger or smaller.

I should do this for nested lists. What I tried doing was adding this line of code before the if len(L) == 1 case.

if isinstance(L[0],list):
    res = min_max(L[0])

elif len(L) == 1:
    res = [L[0], L[0]]

This works partially, but in examples like min_max([[3,2],4]) , returns [2,3] without considering the 4. How can I fix this?

Answer 1

The following works for me:

def min_max(L):
    length = len(L)
    if length == 1:
        if isinstance(L[0],list): // sole element is a list, return its min & max
            return min_max(L[0])
        else:
            return [L[0], L[0]]   // otherwise it is both the min & max
    else:
        mid = length // 2
        result = min_max(L[:mid])  // find min and max of first half of list
        result2 = min_max(L[mid:]) // ditto for second half of list
        // now determine which of the two sets are the min and max of current list
        if (result2[0] < result[0]):
            result[0] = result2[0]
        if (result2[1] > result[1]):
            result[1] = result2[1]
        return result

Note that this cuts lists in half each time, rather than whittling them down by one element at a time. You still end up inspecting every element, but the number of calls on the stack grows proportionally to the log of the list lengths, so this version will work on pretty much any list of lists you could create, where yours will only work on lists with fewer than 1000 elements.

If you're concerned about possibly empty lists or sublists:

def min_max(L):
    length = len(L)
    if length > 1:
        mid = length // 2
        result = min_max(L[:mid])
        result2 = min_max(L[mid:])
        if (result2[0] < result[0]):
            result[0] = result2[0]
        if (result2[1] > result[1]):
            result[1] = result2[1]
        return result
    elif length == 1:
        if isinstance(L[0],list):
            return min_max(L[0])
        else:
            return [L[0], L[0]]
    else:
        return [float('inf'), -float('inf')]

Answer 2

You could simplify your code a bit by passing the current min & max as extra parameters. Then your code basically needs to take care of three different scenarios:

1. Given list is empty -> return min & max from parameters
2. First element on the list is a list -> recurse with the nested list and min & max, then recurse with rest of the list
3. First element on the list is number, update min & max and recurse with rest of the list

In practice the code would look like this:

def min_max(L, minimum=float('inf'), maximum=-float('inf')):
    # Base case, return accumulated result
    if not L:
        return minimum, maximum

    if isinstance(L[0], list):
        # Element is a list, recurse with it
        minimum, maximum = min_max(L[0], minimum, maximum)
    else:
        # Element is a number, update current min & max
        minimum = min(minimum, L[0])
        maximum = max(maximum, L[0])

    # Process rest of the elements on the list
    return min_max(L[1:], minimum, maximum)

print(min_max([[3,2],4]))

Output:

(2, 4)