7/13 包含 min 函数的栈

定义栈的数据结构，请在该类型中实现一个能够得到栈的最小元素的 min 函数在该栈中，调用 min、push 及 pop 的时间复杂度都是 O(1)。

示例:

MinStack minStack = new MinStack();
minStack.push(-2);
minStack.push(0);
minStack.push(-3);
minStack.min();   --> 返回 -3.
minStack.pop();
minStack.top();      --> 返回 0.
minStack.min();   --> 返回 -2.

思路一：

定义一个stack,用数组表示，

求min问题即转化为如何求数组中的最小数，  我个人觉得，直接用python内封装好的min函数就行了，不用自己再写一遍

1直接用python内置的min函数，时间复杂度为O(n)

def find_min(arr):
    if len(arr) == 0:
        return None  # 数组为空，返回 None
    return min(arr)

2.使用遍历查找查找求解数组中的最小数的示例代码：

在无序数组中找到最小数的最佳方法是线性遍历。可以使用一个变量来记录当前的最小数，然后遍历数组，逐个比较元素并更新最小数。

以下是使用线性遍历求解数组中最小数的示例代码：

def find_min(arr):
    if len(arr) == 0:
        return None  # 数组为空，返回 None

    min_num = arr[0]  # 将数组的第一个元素设为当前最小数
    for num in arr:
        if num < min_num:
            min_num = num
    
    return min_num

多次编写及改正

class MinStack(object):

    def __init__(self):

        """

        initialize your data structure here.

        """

        self.stack1=[]

        self.stack2=[]

    def push(self, data):

        """

        :type data: int

        :rtype: None

        """

        self.stack1.append(data)

    def pop(self):

        """

        :rtype: None

        """

        self.stack1.pop()

    def top(self):

        """

        :rtype: int

        """

        self.stack2=self.stack1.pop()

        self.stack1=self.stack1.append(self.stack2)

        return self.stack2

    def min(self):

        """

        :rtype: int

        """

        if len(self.stack1) == 0:

            return None

        else:

            return min(self.stack1)

 

if __name__ == '__main__':

    pass

    def top(self):
        """
        :rtype: int
        """
        self.stack2=self.stack1.pop()
        self.stack1=self.stack1.append(self.stack2)
        return self.stack2

    def min(self):
        """
        :rtype: int
        """
        if len(self.stack1) == 0:
            return None
        else:
            return min(self.stack1)

if __name__ == '__main__':
    pass
 

代码修正

1. 在 push 方法中，self.stack1=self.stack1.append(data) 这一行代码是错误的。append() 方法并不返回新的列表，而是直接在原始列表上进行修改。因此，不需要对 self.stack1 进行赋值操作。可以直接使用 self.stack1.append(data)，将 data 添加到 stack1 中。

2. 在 pop 方法中，self.stack1=self.stack1.pop() 的实现也存在错误。pop() 方法会弹出 stack1 中的最后一个元素，并返回该元素，所以不需要再将其赋值给 self.stack1。应该直接使用 self.stack1.pop() 来移除并丢弃 stack1 的最后一个元素。

3. 在 top 方法中，self.stack2=self.stack1.pop() 的逻辑存在问题。你的意图是取出 stack1 的最后一个元素，但是将其赋值给了 self.stack2。然后又将 self.stack2 添加回 stack1。这种操作会导致 stack1 队列被改变，而且并没有实现 top 方法应有的功能。正确的逻辑是直接使用 return self.stack1[-1] 语句来返回 stack1 的最后一个元素。

4. 在 min 方法中，使用 min(self.stack1) 是正确的，它会返回 stack1 中的最小值。

思路改进：

 使用两个栈，一个用于存储元素的栈 stack，另一个用于存储当前最小值的辅助栈 min_stack。

• 在 push 方法中，当新元素小于等于当前最小值时，将新元素同时压入 stack 和 min_stack，以保证 min_stack 的栈顶元素始终是当前的最小值。
• 在 pop 方法中，如果 stack 的栈顶元素等于 min_stack 的栈顶元素，则说明当前最小值被弹出了，需要将其同时从 stack 和 min_stack 中弹出。
• top 方法直接返回 stack 的栈顶元素，min 方法直接返回 min_stack 的栈顶元素。如果栈为空，则返回 None。qita其他疑惑

class MinStack(object):

    def __init__(self):
        """
        initialize your data structure here.
        """
        self.stack = []  # 存储元素的栈
        self.min_stack = []  # 存储当前最小值的辅助栈

    def push(self, data):
        """
        :type data: int
        :rtype: None
        """
        self.stack.append(data)  # 将元素压入栈

        # 如果辅助栈为空或新元素比当前最小值小或等于当前最小值
        # 则将新元素压入辅助栈，更新当前最小值
        if len(self.min_stack) == 0 or data <= self.min_stack[-1]:
            self.min_stack.append(data)

    def pop(self):
        """
        :rtype: None
        """
        if len(self.stack) == 0:
            return
        
        # 如果栈顶元素等于当前最小值，则将最小值从辅助栈中弹出
        if self.stack[-1] == self.min_stack[-1]:
            self.min_stack.pop()
        
        self.stack.pop()  # 弹出栈顶元素

    def top(self):
        """
        :rtype: int
        """
        if len(self.stack) == 0:
            return None
        
        return self.stack[-1]  # 返回栈顶元素

    def min(self):
        """
        :rtype: int
        """
        if len(self.min_stack) == 0:
            return None
        
        return self.min_stack[-1]

其他疑惑：

1.为什么要用辅助栈：

使用辅助栈的目的是为了在常数时间内获取栈的最小元素。

当我们需要在栈中频繁地获取最小元素时，如果每次都需要遍历整个栈来寻找最小值，时间复杂度将变为O(n)，其中n是栈中元素的数量。为了避免这种情况，我们可以利用辅助栈来跟踪当前的最小值。

辅助栈在每个操作时，都会记录当前的最小值。通过将较小的元素压入辅助栈，我们可以在常数时间内获取到当前最小元素。当最小元素被弹出时，我们同时也从辅助栈中弹出，以确保辅助栈的栈顶元素永远是栈中的最小值。 

这种方法的一个优点是，即使最小元素被弹出后，我们仍然可以在O(1)时间内获取到新的最小值，而不需要重新遍历整个栈。这样可以提高获取最小值的效率。

因此，使用辅助栈可以允许我们以O(1)的时间复杂度获取栈中的最小元素，同时保留了常规栈的基本操作。

 2.为什么栈顶元素是stack[-1]

在Python的列表中，索引从0开始，即列表的第一个元素的索引为0，第二个元素的索引为1，以此类推。

当我们向栈中压入元素时，实际上是将元素添加到列表的末尾，即在列表的最后一个位置添加元素。因此，最后一个元素在列表中的索引就是 len(stack) - 1。

在这个栈的实现中，我们通过 stack[-1] 来访问栈顶元素。通过使用负数索引 -1，我们可以直接访问列表的最后一个元素，即栈顶元素，而不需要手动计算索引值。

例如，假设 stack 是一个非空的列表，那么 stack[-1] 将返回栈顶元素，stack[-2] 将返回倒数第二个元素，以此类推。

因此，在这个实现中，我们使用 stack[-1] 来获取栈顶元素，并且可以在常数时间内进行访问。

反思与收获：

每次返回时还需要考虑是否为空的情况