CSnotes-栈与队列（1-6题）回顾

1，用栈实现队列（务必掌握思想）

232. Implement Queue using Stacks (Easy)

描述
栈：先入后出；队列：先入先出
目标：用栈实现队列的功能，即从先入后出完成先入先出

算法
可建立两个栈，一个作为in栈，一个作为out 栈，元素先全部进in栈，完成一次顺序颠倒，而后再全部依次出栈进out栈，出来，又完成一次顺序颠倒实现先进先出。

代码

class MyQueue(object):

    def __init__(self): 
        """
        Initialize your data structure here.
        """
        self.s1 = []
        self.s2 = []
     
    def push(self, x):  //把元素挨个加入in栈
        """
        Push element x to the back of queue.
        :type x: int
        :rtype: None
        """
        self.s1.append(x)
   
    def pop(self): //把头元素从out栈中找出来并返回
        """
        Removes the element from in front of queue and returns that element.
        :rtype: int
        """
        self.peek()
        return self.s2.pop()
    
    def peek(self):  //元素从in栈中出来再挨个进入out栈
        """
        Get the front element.
        :rtype: int
        """
        if not self.s2:
            while self.s1:
                self.s2.append(self.s1.pop())
        return self.s2[-1]  //返回最先进out列表的元素（即把列表做栈用）
                
    def empty(self): //最后返回in栈与out栈
        """
        Returns whether the queue is empty.
        :rtype: bool
        """
        return not self.s1 and not self.s2

注意
【该范例中最为关键的是def pop(self) 与 def peek(self)这两个方法。其中def pop(self)是为了找出队列中的头元素返回并删除，peek相当于是中介，找到队列头元素，并且辅助完成pop方法的实现。】
‘

’

2，用队列实现栈（务必掌握思想）

225. Implement Stack using Queues (Easy)

描述
栈：先入后出；队列：先入先出
目标：用队列实现栈的功能，即从先入先出完成先入后出

算法
举例： 加入元素CBA，A先进，得到队列【A】，之后B进，得到【B, A】,删去A,得到【B】，A重新进入，得到【A, B】,之后再加入C，最后得到【A,B,C】

代码

class MyStack(object):
    def __init__(self):
        """
        Initialize your data structure here.
        """
        self.queue = collections.deque() 
        
    def push(self, x):   
        """
        Push element x onto stack.
        :type x: int
        :rtype: None
        """
        q = self.queue
        q.append(x)
        for i in range(len(q)-1):
            q.append(q.popleft())
           
    def pop(self):   //移除队列头部元素并返回
        """
        Removes the element on top of the stack and returns that element.
        :rtype: int
        """
        return self.queue.popleft()

    def top(self):   //输出队头元素，但不移除
        """
        Get the top element.
        :rtype: int
        """
        return self.queue[0]  

    def empty(self):  //判断队列是否为空，空输出FALSE
        """
        Returns whether the stack is empty.
        :rtype: bool
        """
        return not len(self.queue)

‘

’

3，最小值栈

155. Min Stack (Easy)

代码

class MinStack(object):

    def __init__(self):
        """
        initialize your data structure here.
        """
        self.stack = []

    def push(self, x):
        """
        :type x: int
        :rtype: None
        """
        if not self.stack:
            self.stack.append((x,x))
        else:
            self.stack.append((x, min(self.getMin(), x)))
        
    def pop(self):
        """
        :rtype: None
        """
        self.stack.pop()


    def top(self):
        """
        :rtype: int
        """
        if self.stack:
            return self.stack[-1][0]

    def getMin(self):
        """
        :rtype: int
        """
        if self.stack:
            return self.stack[-1][-1]
        return sys.maxint     

关键
（1）设定：stack = [ (1, 2) ,(2, 3) ]，stack.append((4,5))，则stack= [ (1, 2) ,(2, 3)，(4,5)]
（2）stack[-1] [0] = 4
’

’

栈的思想

4. 用栈实现括号匹配

20. Valid Parentheses (Easy)

代码

class Solution(object):
    def isValid(self, s):
        """
        :type s: str
        :rtype: bool
        """
        stack = []
        dire = {"}":"{","]":"[",")":"("}
        
        for char in s:
            if char in dire.values():
                stack.append(char)
            elif char in dire.keys():
                if stack == [] or dire[char] != stack.pop():
                    return False
            
        return stack == []

关键
本题最后的stack == [ ] 处理的很妙，相当于把列表当栈使用，不能处理的先放栈里,之后再处理，处理时不管能不能匹配，都用pop函数把他提出来并返回结果。
’

’

5. 数组中元素与下一个比它大的元素之间的距离

739. Daily Temperatures (Medium)

代码

class Solution(object):
    def dailyTemperatures(self, T):
        """
        :type T: List[int]
        :rtype: List[int]
        """
        ans = [0]*len(T)
        stack = []
        
        for i, index in enumerate(T):
            while stack and index > T[stack[-1]]:
                cur = stack.pop()
                ans[cur] = i-cur
                
            stack.append(i)
            
        return ans

关键
此题中，stack作为栈，用于存储未处理的数据的下标，当发现比他大的数据之后，就可处理该数据，并将该下标从栈中提取出来。
’

’

6. 循环数组中比当前元素大的下一个元素

503. Next Greater Element II (Medium)

代码

class Solution(object):
    def nextGreaterElements(self, nums):
        """
        :type nums: List[int]
        :rtype: List[int]
        """
        stack = []
        ans = [-1] * len(nums)
        
        for i in range(len(nums)) * 2:
            while (stack != []) and (nums[i] > nums[stack[-1]]):
                ans[stack.pop()] = nums[i]
            stack.append(i)
        return ans

关键
1, [举例] A=[“a”,“c”,“v”,“d”],则range(len(A))为[0,1,2,3],range（object）返回的是一个列表，故而，range(len(A)) * 2得到的即[0,1,2,3,0,1,2,3]
2, 此处循环两次,是为了便于像[1,2,1]中的第二个1找到比他大的数2.
3, 本题思想与5题异曲同工之妙。