Data Structure stack & queue

1.栈

栈的抽象数据结构
栈是限制在表的一端进行插入和删除的线性表。允许插入，删除的这一端称为栈顶，另一端固定端称为栈底。当表内无元素时称为空栈。
栈是有序的LIFO(后进先出)。
栈的操作有：

• Stack() 创建新的空栈。
• push(item) 添加新项到栈顶部。
• pop() 删除栈顶项并返回栈顶项的值。栈被修改。
• peek() 返回栈顶部项。不修改栈。
• isEmpty() 测试栈是否为空，返回 Bool 值。
• size() 返回栈长度（栈中 item 数量）。

栈可以通过数组或者链表轻松实现

1.1 列表实现栈

class Stack:
    def __init__(self):
        self.items = []
    
    def isEmpty(self):
        return self.items == []
    
    def push(self, item):
        self.items.append(item)
    
    def pop(self):
        return self.items.pop()
    
    def peek(self):
        return self.items[-1]
    
    def size(self):
        return len(self.items)

if __name__ == '__main__':
    s = Stack()
    print(s.isEmpty())
    s.push(4)
    s.push('Rocket')
    print(s.peek())
    s.push(True)
    print(s.size())
    print(s.isEmpty())
    s.push(88
    print(s.pop())
    print(s.pop())
    print(s.size())    

1.2 简单括号匹配

python3实现：

# coding=utf-8
class Stack:
    def __init__(self):
        self.items = []

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

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

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

    def peek(self):
        return self.items[-1]

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


def parChecker(symbol_string):
    s = Stack()
    balanced = True
    index = 0
    while index < len(symbol_string) and balanced:
        symbol = symbol_string[index]
        if symbol == '(':
            s.push(symbol)
        else:
            if s.isEmpty():
                balanced = False
            else:
                s.pop()
        index += 1

    if balanced and s.isEmpty():
        return True
    else:
        return False

print(parChecker('((()))'))
print(parChecker('((()'))

from stack import Stack

def check(strings):
    s = Stack()
    for string in strings:
        if string == '(':
            s.push(string)
        elif string == ')':
            try:
                s.pop()
            except IndexError:
                return False
        else:
            return False
    return s.isEmpty()


print(check('((()))'))
print(check('()))'))

2.队列

队列是限制结点插入操作固定在一端进行,而结点的删除操作固定在另一端进行的线性表.

• 基本思想
  • 先进先出FIFO
  • 操作：
    • Enqueue:将一个项目添加到队列的末尾
    • Dequeue:从队列前面移除一个项目
    • size:返回队列中当前的项目数量
    • peek:返回队列的当前顶层元素而不是删除它
  • 队列可以通过（循环）数组或链表实现

2.1 栈实现队列：

# coding=utf-8
# 使用栈实现队列
class QueueWithTwoStack:
    def __init__(self):
        self.insertStack = []
        self.popStack = []

    def enqueue(self,e):
        self.insertStack.append(e)
        return e

    def dequeue(self):
        if len(self.insertStack)==0 and len(self.popStack)==0:
            return None
        if len(self.popStack) == 0:
            while len(self.insertStack)!=0:
                self.popStack.append(self.insertStack.pop())
        return self.popStack.pop()

mystack = QueueWithTwoStack()
e = mystack.enqueue(8)
print(e)
e = mystack.enqueue(9)
print(e)
e = mystack.enqueue(10)
print(e)
print(mystack.dequeue())
print(mystack.dequeue())
print(mystack.dequeue())