是否可以使用reduce对列表进行排序？

Question

这是作为练习的。我当然可以使用 sorted() 或 Python 标准库中的其他方式对列表进行排序，但在这种情况下我不能。我认为我应该只使用 reduce()。

from functools import reduce
arr = [17, 2, 3, 6, 1, 3, 1, 9, 5, 3]
sorted_arr = reduce(lambda a,b : (b,a) if a > b else (a,b), arr)

我得到的错误：

TypeError: '>' not supported between instances of 'tuple' and 'int'

这是意料之中的，因为我的 reduce 函数将一个元组插入到 int 数组中，而不是 2 个单独的整数。然后将元组与 int 进行比较...

有没有办法将 2 个数字插入到列表中，并且只对列表中的每个第二个数字运行该函数？还是一种使用 reduce() 交换数字的方法？

文档对reduce函数的描述很少，所以我现在没有想法。 https://docs.python.org/3/library/functools.html?highlight=reduce#functools.reduce

Answer 1

让我们理解这一点
(1)Reduce的使用基本上是将表达式归约为单个最终值 (2)reduce()存储中间结果，只返回最终的求和值
(3)我们将使用reduce取最小元素，将其附加到sorted_list并从原始列表中删除
(4) 现在 reduce 将对其余元素起作用并再次重复第 3 步
(5)while list_nums: 将一直运行到列表为空

list_of_nums = [1,19,5,17,9]
sorted_list=[]
while list_of_nums:
    maxvalue=reduce(lambda x,y: x if x<y else y,list_of_nums)
    sorted_list.append(maxvalue)
    list_of_nums.remove(maxvalue)
print(sorted_list)

[1, 5, 9, 17, 19]

Answer 2

我认为您误解了 reduce 的工作原理。在其他一些语言（例如 Haskell）中，Reduce 是 right-fold 的同义词。第一个参数需要一个带有两个参数的函数：一个累加器和一个要累加的元素。

让我们破解它：

arr = [17, 2, 3, 6, 1, 3, 1, 9, 5, 3]
reduce(lambda xs, x: [print(xs, x), xs+[x]][1], arr, [])

这里，xs 是累加器，x 是要累加的元素。不要太担心[print(xs, x), xs+[x]][1] - 它只是打印xs 和x 的中间值。如果没有打印，我们可以将 lambda 简化为 lambda xs, x: xs + [x]，它只是附加到列表中。

以上输出：

[] 17
[17] 2
[17, 2] 3
[17, 2, 3] 6
[17, 2, 3, 6] 1
[17, 2, 3, 6, 1] 3
[17, 2, 3, 6, 1, 3] 1
[17, 2, 3, 6, 1, 3, 1] 9
[17, 2, 3, 6, 1, 3, 1, 9] 5
[17, 2, 3, 6, 1, 3, 1, 9, 5] 3

正如我们所见，reduce 传递一个累积列表作为第一个参数，一个新元素作为第二个参数。（如果 reduce 仍然让你感到困惑，How does reduce work? 包含一些很好的解释。）

我们的特定 lambda 在每次“迭代”时插入一个新元素到累加器中。这暗示了插入排序：

def insert(xs, n):
    """
    Finds first element in `xs` greater than `n` and returns an inserted element.
    `xs` is assumed to be a sorted list.
    """
    for i, x in enumerate(xs):
        if x > n:
            return xs[:i] + [n] + xs[i:]

    return xs + [n]

sorted_arr = reduce(insert, arr, [])
print(sorted_arr)

这将打印正确排序的数组：

[1, 1, 2, 3, 3, 3, 5, 6, 9, 17]

^{请注意，reduce 的第三个参数（即[]）是指定的，因为我们初始化排序应该使用一个空列表。}

Answer 3

经过一番思考，我得出结论，如果允许您多次使用reduce，也可以进行基于交换的排序。即：

from functools import reduce
arr = [17, 2, 3, 6, 1, 3, 1, 9, 5, 3]
def func(acc,x):
    if not acc:
        return [x]
    if acc[-1]<x:
        return acc+[x]
    else:
        return acc[:-1]+[x]+acc[-1:]

def my_sort(x):
    moresorted = reduce(func,x,[])
    print(moresorted)
    if x==moresorted:
        return moresorted
    else:
        return my_sort(moresorted)

print('arr:',arr)
arr_sorted = my_sort(arr)
print('arr sorted:',arr_sorted)

输出：

arr: [17, 2, 3, 6, 1, 3, 1, 9, 5, 3]
[2, 3, 6, 1, 3, 1, 9, 5, 3, 17]
[2, 3, 1, 3, 1, 6, 5, 3, 9, 17]
[2, 1, 3, 1, 3, 5, 3, 6, 9, 17]
[1, 2, 1, 3, 3, 3, 5, 6, 9, 17]
[1, 1, 2, 3, 3, 3, 5, 6, 9, 17]
[1, 1, 2, 3, 3, 3, 5, 6, 9, 17]
arr sorted: [1, 1, 2, 3, 3, 3, 5, 6, 9, 17]

出于教育目的，我将print(moresorted) 放在func 中，如果您愿意，可以将其删除。

现在解释一下：my_sort 是递归函数，随着它的每次运行，列表变得越来越有序。在reduce 中用作函数的func 确实追加了新元素，然后如果它们不是升序，则交换列表的最后两个元素。 这意味着在my_sort 的每次运行中，数字都会向右“移动”，直到下一个数字更大。 启动需要if not acc - 请注意reduce 的第三个参数是[]，这意味着在第一次执行func 中每个reduce func 的第一个参数是[]，所以问acc[-1]<x？会导致错误。

Answer 4

忍者！但是，是的，它是一种插入排序。

def insert(acc, e):
    for i, x in enumerate(acc):
        if x > e:
            acc.insert(i, e)
            return acc
    acc.append(e)
    return acc

reduce(insert, [1, 2, 6, 4, 7, 3, 0, -1], [])

输出

[-1, 0, 1, 2, 3, 4, 6, 7]

Answer 5

这是使用reduce 对列表进行排序的一种方法：

arr = [17, 2, 3, 6, 1, 3, 1, 9, 5, 3]
sorted_arr = reduce(
    lambda a, b: [x for x in a if x <= b] + [b] + [x for x in a if x > b],
    arr,
    []
)
print(sorted_arr)
#[1, 1, 2, 3, 3, 3, 5, 6, 9, 17]

在每个 reduce 步骤中，构建一个新的输出列表，该列表连接所有小于或等于 b、[b] 的值的列表以及所有大于 b 的值的列表。使用reduce 的可选第三个参数将输出初始化为一个空列表。