從python中嵌套列表的索引中查找下一個最大值？

Question

我正在嘗試查找嵌套列表的下一個最大值，我已經有一個按冒泡排序排序的嵌套列表，我需要將每個嵌套列表的最大元素插入到解向量中，直到對解向量進行排序。 PS：我無法從初始嵌套列表中刪除元素，只能找到下一個最大值。 以底部的圖像為例：

Nested_list = [[1, 7, 9], [4, 5, 6], [2, 3, 8], [0]]

我設計的方式從原始列表中刪除了最大的向量，這非常耗時，我相信只需將索引移動到下一個最大值將消耗更少的時間：

def bubbleSort(array):
    n = len(array)-1
    for i in range(n):
        for j in range(0, n-i):
            if array[j] > array[j+1]:
                array[j], array[j+1] = array[j+1], array[j]
            else:
                continue
    return array

def ordena_lista(output): 
    for sublista in output:
        bubbleSort(sublista)
       
        
def maior_valor_lista(output):
    return list(el[-1] for el in output)


def nested_remove(L, x):
    if x in L:
        L.remove(x)
    else:
        for element in L:
            if type(element) is list:
                nested_remove(element, x)

b = list(random.sample(range(10), 10))
n= m.floor(m.sqrt(len(b)))
output=list([b[i:i + n] for i in range(0, len(b), n)])
ordena_lista(b)
while output:
        valores_maximo = maior_valor_lista(output)
        var = max(valores_maximo, key=int)
        final = [var] + final
        nested_remove(output, var)
        output = list(filter(None, output))

Answer 1

這相當於一個奇怪的、可悲的低效且完全不必要的排序算法，但無論如何：

Nested_list = [[9, 7, 1], [4, 5, 6], [2, 3, 8], [0]]

for e in Nested_list:
    e.sort()

Output_list = []

Nested_list_copy = [[e_ for e_ in e] for e in Nested_list]

element_count = sum(len(e) for e in Nested_list)

for _ in range(element_count):
    m = None
    for i, e in enumerate(Nested_list_copy):
        if e:
            tm = e[-1]
            if m is None or tm > m:
                m = tm
                k = i
    Output_list.insert(0, Nested_list_copy[k].pop())

print(Nested_list)
print(Output_list)

輸出：

[[1, 7, 9], [4, 5, 6], [2, 3, 8], [0]]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Answer 2

最簡單的解決方案如下，

from functools import reduce
from operator import add


def sort_nested_list(nested_list):
   return sorted(reduce(add, nested_list))

但是，在不知道 python 排序的確切實現細節的情況下，我無法告訴你它是否利用了你的預排序。

如果我們知道子列表已排序，並且我們可以復制列表，並且我們知道總共有多少元素，我們可以編寫以下內容，

import math
from copy import deepcopy


def get_max_and_pop(nested_list):
    """ find the maximum element of a sublist of nested_list, remove it from the sublist, and return it """
    print(f"get_max_and_pop says: {nested_list}")
    return max(nested_list, key=lambda x: x[-1:]).pop()


def sort_nested_list_whose_sublists_are_sorted(nested_list, n_elements):
    nested_list_copy = deepcopy(nested_list)
    return [get_max_and_pop(nested_list=nested_list_copy) for _ in range(n_elements)][::-1]

編輯：不知道元素的數量，我們可以寫，

from copy import deepcopy


def sort_nested_list_whose_sublists_are_sorted_iter(nested_list):
    nested_list_copy = deepcopy(nested_list)
    while any(nested_list_copy):
        yield max(nested_list_copy, key=lambda x: x[-1:]).pop()