列表的最小值和最大值（不使用 min/max 函數）

Question

我想知道是否有一種方法可以在不使用 Python 中的最小值/最大值函數的情況下找到列表的最小值和最大值。 所以我用遞歸寫了一個小代碼。 我的邏輯非常幼稚：我制作了兩個堆棧（ min_stack和max_stack ），它們在每次遞歸調用期間跟蹤最小值和最大值。 我有兩個問題：

1. 有人可以幫我估計代碼的復雜性嗎？
2. 有一個更好的方法嗎？ 使用合並排序/快速排序對列表進行排序並選擇第一個和最后一個元素會帶來更好的性能嗎？

這是我在 Python 中的嘗試：

minimum = []
maximum = []

# Defining Stack Class
class Stack:
    def __init__(self) :
        self.items = []

    def push(self, item) :
        self.items.append(item)

    def pop(self) :
        return self.items.pop()

    def access(self, index):
        return self.items[index]

    def isEmpty(self) :
        return (self.items == [])

    def length(self):
        return len(self.items)

def minmax(input_list):
    # make two stacks, one for min and one for max
    min_stack = Stack()
    max_stack = Stack()
    # comparing the first two elements of the list and putting them in appropriate stack
    if input_list[0]<input_list[1]:
        min_stack.push(input_list[0])
        max_stack.push(input_list[1])
    else:
        max_stack.push(input_list[0])
        min_stack.push(input_list[1])

    # Pushing remaining elements of the list into appropriate stacks. 
    for i in range(2, len(input_list)):
        if input_list[i] < min_stack.access(-1):
            min_stack.push(input_list[i])
        else:
            max_stack.push(input_list[i])

    # to find minimum
    minlist = []
    while min_stack.length() > 0:
        minlist.append(min_stack.pop())

    # to find maximum
    maxlist = []
    while max_stack.length() > 0:
        maxlist.append(max_stack.pop())

    if len(minlist) > 1:
        minmax(minlist)
    else:
        minimum.append(minlist)


    if len(maxlist) > 1:
        minmax(maxlist)
    else:
        maximum.append(maxlist)

def main():
    input_list = [2, 0, 2, 7, 5, -1, -2]
    print 'Input List is: ', input_list
    minmax(input_list)

print 'Global Minimum is: ', minimum[0]
print 'Global Maximum is: ', maximum[len(maximum)-1]

if __name__ == "__main__":
    main()

Answer 1

當然，對於中等大小的列表，使用sorted()將是可靠的、快速的編寫和高性能的，因為它是內置的。 對於大型列表，O(n) 算法會更快，例如：

def minmax1 (x):
    # this function fails if the list length is 0 
    minimum = maximum = x[0]
    for i in x[1:]:
        if i < minimum: 
            minimum = i 
        else: 
            if i > maximum: maximum = i
    return (minimum,maximum)

print(minmax1([9,8,7,6,5,4,3,2,1,11,12,13,14,15,16,17,18,19]))
print(minmax1([1]))
print(minmax1([2, 0, 2, 7, 5, -1, -2]))

...其輸出為：

(1, 19)
(1, 1)
(-2, 7)

我有興趣檢查這兩種替代方案的性能。 在我運行 Windows XP 和 Python 3.2.3 的 PC 上，我發現排序方法比上面為少於 500 個元素的列表定義的minmax1()函數更快，但是對於更長的列表，O(n) minmax1()是快點。 我的時序測試代碼如下：

def minmax_sort(x):
    x = sorted(x)
    return (x[0],x[-1])

import timeit

aa = list(range(0,100))
a = aa
while (1):
    stime = min(timeit.repeat('minmax_sort(a)', "from __main__ import minmax_sort,a",number=1000))
    mtime = min(timeit.repeat('minmax1(a)', "from __main__ import minmax,a",number=1000))
    if (stime > mtime):
        break
    else:
        a = a + aa
print(len(a))

Answer 2

僅使用遞歸查找列表的最小值和最大值。

上周我有類似的任務，我將代碼分為三個部分。

第 1 步：查找列表中的最小值

def RecursiveMin(L):
    if len(L)==2:
        if L[0]<L[1]:
            return L[0]
        else:
            return L[1]
    else:
        X= RecursiveMin(L[1:])
        if L[0]<X:
            return L[0]
        else:
            return X

第 2 步：使用升序對列表進行排序（從小到大）

def Sort(x):
    L=sorted(x)
    if x==L:
        return x
    else:
        i=0
        for i in range (len(x)):
            if x[i] > x[i+1] :
                break
        
        unsortedPart = x[i:]
        R = RecursiveMin(unsortedPart)
        I = unsortedPart.index(R)
        
        for j in range (len(x)):
            if x[j] > R :
                del x[(I+i)]
                x.insert(j,R)
                break
        
        return Sort(x)

（我之前回答了一個排序列表問題並提供了相同的代碼。所以請不要標記我抄襲，因為這是我自己的代碼 Likn： Finding minimum element in a list (recursively) - Python ）。

*第 3 步：使用參數創建一個新函數，無論用戶想要最小值還是最大值

def minMax(lst,user):
    if user == min:
       return Sort(lst)
    elif user == max:
       s = Sort(lst)
       return s[::-1]

最后一步不是遞歸的，但如果將所有三個步驟編譯成一個函數，它將是“1 個遞歸函數”。
PS如果您的問題只是關於在列表中查找最小值和最大值，您可以跳過第 2步並對第 1 步和第 3步進行一些更改

Answer 3

這將非常簡單易懂。 希望這會幫助你。

arr = []
num = int(input("Enter number of elements in list: ")) 
for i in range(0, num): 
    ele = int(input("Enter elements: ")) 
    arr.append(ele)

min = arr[ 0 ]
for a in arr:
    if a < min:
        min = a
print ("The minimum number in the list is: ", min)

max = arr[0]
for a in arr:
    if a > max:
        max = a
print("The maximum number in the lit is: ", max)

Answer 4

我被要求使用 Stacks 作為一種鍛煉方式來實現它。

我很驚訝有幾個解決方案需要多次遍歷列表來確定最小值和最大值。 這是一個簡單的 Python 3 遞歸解決方案，每個 OP 使用堆棧，它只使一個通過列表：

def minmax(array, minimum=None, maximum=None):

    head, *tail = array

    if minimum is None:
        minimum = [head]
    elif head < minimum[-1]:
        minimum.append(head)

    if maximum is None:
        maximum = [head]
    elif head > maximum[-1]:
        maximum.append(head)

    if tail:
        return minmax(tail, minimum, maximum)

    return minimum.pop(), maximum.pop()

if __name__ == "__main__":

    array = [2, 0, 2, 7, 5, -1, -2]
    minimum, maximum = minmax(array)
    print(array, minimum, maximum)

    array = [13]
    minimum, maximum = minmax(array)
    print(array, minimum, maximum)

    array = [9, 8, 7, 6, 5, 4, 3, 2, 1, 11, 12, 13, 14, 15, 16, 17, 18, 19]
    minimum, maximum = minmax(array)
    print(array, minimum, maximum)

盡管堆棧對於此代碼的工作並不是絕對必要的。

Answer 5

為了找到最大值，我們可以使用以下邏輯：

def mx(y):
    max_n = y[0] # initial the max to the first element

for i in range(len(y)-1): # for every element check if its greater than max.
    if y[i+1]>max_n:
        max_n = y[i+1] # if so, assign max to the value
return(max_n) 
      

Answer 6

如果您使用 sorted() 函數，只需調用第一個索引為最小值，最后一個索引為最大值。 不需要 for 循環。

def minimum(x):
    x = sorted(x)
    return x[0]

def maximum(x):
    x = sorted(x)
    return x[-1]

print(minimum([2, -5, 79, 20, -67])
print(maximum([45, -78, 950, 39, -567])

輸出是：

-67
950

Answer 7

def inIntervalle(liste, min, max):
    liste_intervalle = []
    for i in range(len(liste)):
        if liste[i] < max and liste[i] > min:
            liste_intervalle.append(liste[i])
    return liste_intervalle 

Answer 8

這是一個使用遞歸函數的簡單解決方案。 讓arr成為您的數字列表。 可以通過到達列表末尾並一次比較最后 2 個數字並將結果傳播回前一個函數調用，一直到第一個元素，可以找到最小值/最大值。

def get_min_max(arr):
    min = find_peak(arr, peak = "minimum")
    max = find_peak(arr, peak = "maximum")
    return {"minimum": min, "maximum": max}

def find_peak(arr, peak):
    if len(arr) == 1: # base condition
        return arr[0]    
    n1 = arr[0]
    n2 = find_peak(arr[1:], peak) # first element removed for each call
    if peak == "maximum":
        if n1 > n2: 
            return n1
        else:
            return n2
    else:
        if n1 < n2: 
            return n1
        else:
            return n2

Answer 9

# l=[2,3,5,4,343,54,2,882,53453,66,3]
l=[1,2,3,4]

for i in l:
  if l[0]>l[1]:
    del l[1]
  else:
    del l[0]
for i in l:
  if l[1]>l[0]:
    del l[0]
  else:
    del l[1]
if len(l)>1:
  for i in l:
    if l[0]>l[1]:
      del l[1]
    else:
      del l[0]   

Answer 10

min=99999999999999
while True:
    value=int(input('enter your values:'))
    if value==333: #enter 333 to end the input
        break
    if min>value:
        min=value
print(min)  

Answer 11

不使用 min() 和 max() 函數，返回數組中最大值和最小值之間的差

list1 = [10, 3, 5, 6]
maximum = minimum = list1[0]
for i in list1:
    
    if i > maximum: 
        maximum = i 
    else:  
        if i < minimum: minimum = i

print(abs(minimum-maximum))

從其他答案編輯

Answer 12

如果您必須避免使用內置插件，這非常簡單。

您可以從列表中獲取一個值並繼續檢查現有值，然后更新最小值，如下所示。

def min_in_list(fin_list):
    min_val = fin_list[-1]
    for val in fin_list:
        if(val<=min_val):
            min_val = val
    return min_val

fin_list = [9,8,7,6,5,4,3,2,1,11,12,13,14,15,16,17,18,0,19]
print(min_in_list(fin_list))