如何在矩阵中找到最低的3个值 输出：输出：

如何解决如何在矩阵中找到最低的3个值 输出：输出：

所以我有这个功能来找到矩阵中的最小值，并返回它在矩阵中的位置，即它的索引：

final_matrix=[[3.57 2.71 9.2 5.63]
              [4.42 1.4 3.53 8.97]
              [1.2 0.33 6.26 7.77]
              [6.36 3.6 8.91 7.42]
              [1.59 0.9 2.4 4.24]] # this changes in my code,im just giving a very simple version of it here

def lowest_values(final_matrix):
best_value=10000 #or any arbitrarily high number 
    for i in range(0,len(final_matrix[:,0])):
        for j in range(0,len(final_matrix[0,:])):
            if final_matrix[i,j]<best_value:
                best_value=final_matrix[i,j]
                lowest_val_i=i
                lowest_val_j=j
    return(lowest_val_i,lowest_val_j)

这将返回我 (1,2)，仅通过视觉分析是正确的。我现在想找到最低的 3 个值 - 希望能构建到这个循环中。但我真的想不通怎么办！或者至少我不知道如何实现它。我在想一些 if-else 循环，如果已经找到最低值，那么“void”这个值并找到第二个最低值，然后同样的事情找到第三个。但我不确定。

请不要太快关闭这个问题 - 我对编程很陌生，而且很卡！

解决方法

人性化的方法

我认为我的方法与分享的不同答案有很大不同。

我只对每个列表元素进行 3 次比较，所以它应该是 O(n)。此外，我没有创建一个全新的列表，其中包含所有元素的 (value,index) 元组。

matrix=[[3.57,2.71,9.2,5.63],[4.42,1.4,3.53,8.97],[1.2,0.33,6.26,7.77],[6.36,3.6,8.91,7.42],[1.59,0.9,2.4,4.24]]
              
            
def compare_least_values(value,i,j):
    global least
    if value < least[2][0] :
        if value < least[1][0] :
            if value < least[0][0] :
                least.insert(0,(value,(i,j)))
            else:
                least.insert(1,j)))
        else:
            least.insert(2,j)))
    

def lowest_three_values(matrix): 
    global least
    least = [(10000,(None,None)),(10000,None))]  
    for i,row in enumerate(matrix):
        for j,value in enumerate(row):
            compare_least_values(value,j)
    return least[:3]
    
print(lowest_three_values(matrix))

输出：

[(0.33,(2,1)),(0.9,(4,(1.2,0))]

实用方法（Numpy）

如果您熟悉 numpy，那么这就是您要走的路。即使您不是，它也可以用作复制粘贴片段。

import numpy as np

matrix=[[3.57,4.24]]
matrix = np.array(matrix)

indices_1d = np.argpartition(matrix,3,axis=None)[:3]
indices_2d = np.unravel_index(indices_1d,matrix.shape)
least_three = matrix[indices_2d]

print('least three values : ',least_three)
print('indices : ',*zip(*indices_2d) )

输出：

least three values :  [0.33 0.9  1.2 ] 
indices :  (2,1) (4,1) (2,0)

有关此问题的详细答案，请参阅此 Stackoverflow query。

,

我不明白返回的东西 (1,2)。矩阵的最低值为 0.33。那个位置是 (2,1)。

所以我的代码解决方案；

all_items = []
# i appended matrix's all items to one list
for row in final_matrix:
    for i in row:
        all_items.append(i)
# and i sorted that list as from min to max
all_items.sort()
# then i took first 3 values
lowest_3 = all_items[0:3]
positions = []
# and i append their positions that's in the matrix into positions
for i in lowest_3:
    for row in range(len(final_matrix)):
        if(i in final_matrix[row]):
            positions.append([row,final_matrix[row].index(i)])
            break

# lowest_3  = [0.33,1.2]
# positions = [[2,1],[4,[2,0]]

,

这是我的解决方案：

final_matrix=[[3.57,4.24]]

min_values = []
for i in range(3):
    mini = final_matrix[0][0]
    for row in final_matrix:
        for n in row:
            if n < mini:
                mini = n
                n_index = row.index(n)
                row_index = final_matrix.index(row)
    min_values.append(mini)
    del final_matrix[row_index][n_index]


print("Finals {}".format(min_values))

让我解释一下： 第一个循环遍历你想要的最小值（改变它，你会明白我的意思） 第二个和最后一个，遍历矩阵以取最小值 行 del final_matrix[row_index][n_index] 将破坏原始矩阵中的最小数 因此，如果您想保留原始矩阵，则必须创建一个新矩阵并将原始矩阵复制到 => 使用复制模块中的 deepcopy()

,

您正在从项目列表（或本例中的“矩阵”）中寻找 N 个最小的项目，当 N 很小时，您可以通过创建一个 heap queue ，这需要线性时间，然后通过弹出 N 个最小元素，这是每次弹出的 O(log N) 操作。 heap queue 是一种重要的数据结构，您应该研究一下。

import heapq

final_matrix=[[3.57,4.24]]

def lowest_values(final_matrix):
    # create a flat list,l,from the matrix
    # each element is a tuple: (value,x-coordinate,y-coordinate)
    l = [(final_matrix[x][y],x,y)
        for x in range(len(final_matrix))
            for y in range(len(final_matrix[0]))
        ]
    heapq.heapify(l) # O(N) time
    for _ in range(3):
        # pop next smallest tuple:
        value,y = heapq.heappop(l) # O(log N) time
        print(f'value={value},x={x},y={y}')

lowest_values(final_matrix)

打印：

value=0.33,x=2,y=1
value=0.9,x=4,y=1
value=1.2,y=0

注意

上面的代码可以简化为以下代码，如果您只需要 3 个最小的项目，并且不再需要堆队列结构，那么效率可能会更高。但是我想展示从列表创建堆队列然后从该堆队列中连续生成最小项的两个基本操作：

import heapq

final_matrix=[[3.57,y)
        for x in range(len(final_matrix))
            for y in range(len(final_matrix[0]))
        ]
    for value,y in heapq.nsmallest(3,l):
        print(f'value={value},y={y}')

lowest_values(final_matrix)