Python中列表的最小值和最大值（不使用最小值/最大值函数）

我想知道是否有一种方法可以在不使用Python中的min/max函数的情况下找到列表的min&max。因此，我使用递归编写了一个小代码。我的逻辑非常简单：我创建了两个堆栈（min_stack和max_stack），它们在每次递归调用期间跟踪最小值和最大值。我有两个问题：

有人能帮我估计一下代码的复杂性吗

有更好的方法吗？使用mergesort/quicksort对列表进行排序，并拾取第一个和最后一个元素是否会提供更好的性能

多谢各位

以下是我在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()

最小值=[]
最大值=[]
#定义堆栈类
类堆栈：
定义初始化（自）：
self.items=[]
def推送（自身，项目）：
self.items.append（项目）
def pop（自我）：
返回self.items.pop（）
def访问（自，索引）：
返回self.items[索引]
定义为空（self）：
返回（self.items==[]）
def长度（自身）：
返回len（自我项目）
def最小最大值（输入列表）：
#制作两个堆栈，一个用于最小值，一个用于最大值
最小堆栈=堆栈（）
最大堆栈=堆栈（）
#比较列表的前两个元素并将它们放入适当的堆栈中
如果输入_列表[0]0：
追加（minu stack.pop（））
#求最大值
maxlist=[]
当max_stack.length（）大于0时：
maxlist.append（max_stack.pop（））
如果len（minlist）>1：
最小最大值（最小列表）
其他：
最小值。追加（最小值列表）
如果len（maxlist）>1：
最小最大值（最大值列表）
其他：
maximum.append（maxlist）
def main（）：
输入列表=[2,0,2,7,5，-1，-2]
打印“输入列表为：”，输入列表
最小最大值（输入列表）
打印“全局最小值为：”，最小值[0]
打印“全局最大值为：”，最大值[len（最大）-1]
如果名称=“\uuuuu main\uuuuuuuu”：
main（）
使用
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]))

我有兴趣检查两个备选方案的性能。在运行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))

仅使用递归查找列表的最小值和最大值。
上周我有一个类似的任务，我把代码分为三个部分

步骤1：在列表中查找最小值

（我以前回答过一个排序列表问题，并提供了相同的代码。所以请不要因为我的代码是我自己的，而将我标记为剽窃。）
喜欢：）

**步骤3：创建一个带有参数的新函数，该参数是用户想要的最小值还是最大值*

最后一步不是递归的，但如果将所有三个步骤编译成一个函数，它将是“1个递归函数”。
P.S如果您的问题只是关于在列表中查找最小值和最大值，您可以跳过步骤2，并对步骤1和步骤3
进行一些更改。如果您使用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])

输出为：

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

-67
950

这将是非常简单和容易理解的。希望这对你有帮助

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)

arr=[]
num=int（输入（“输入列表中的元素数量：”）
对于范围内的i（0，num）：
ele=int（输入（“输入元素：”）
arr.append（ele）
最小值=arr[0]
对于arr中的a：
如果a最大值：
最大值=a
打印（“灯中的最大数字为：”，最大值）

我被要求使用堆栈作为一种练习方式来实现它

我很惊讶有几个解决方案需要多次通过列表来确定最小值和最大值。下面是一个简单的Python 3递归解决方案，每个操作使用堆栈，它只通过列表一次：

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)

def minmax（数组，最小值=无，最大值=无）：
头，*尾=数组
如果最小值为无：
最小值=[头]
elif头<最小值[-1]：
最小值。追加（头）
如果最大值为无：
最大值=[头]
elif头>最大值[-1]：
最大附加值（头）
如果是尾部：
返回最小最大值（尾部、最小值、最大值）
返回minimum.pop（），maximum.pop（）
如果名称=“\uuuuu main\uuuuuuuu”：
数组=[2,0,2,7,5，-1，-2]
最小值，最大值=最小最大值（数组）
打印（数组、最小值、最大值）
数组=[13]
最小值，最大值=最小最大值（数组）
打印（数组、最小值、最大值）
数组=[9,8,7,6,5,4,3,2,1,11,12,13,14,15,16,17,18,19]
最小值，最大值=最小最大值（数组）
打印（数组、最小值、最大值）

尽管堆栈对于此代码的工作来说并不十分必要。
definintervalle（liste、min、max）：
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 

间隔时间=[]
对于范围内的i（len（liste））：
如果liste[i]min：
liste_intervalle.append（liste[i]）
返回间隔列表
为了找到max，我们可以使用以下逻辑：

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) 
      

哇！这看起来真的太复杂了…我假设使用排序并获取0和-1索引会更快。。。可读性更高的
a=sorted（我的列表）；最小值，最大值=a[0]，a[-1]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)

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 

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)