class Queue:
def __init__(self):
self.inbox = Stack()
self.outbox = Stack()
def enqueue(self, item):
while self.outbox.size() != 0:
self.inbox.push(self.outbox.pop())
self.inbox.push(item)
def dequeue(self):
while self.inbox.size() != 0:
self.outbox.push(self.inbox.pop())
return self.outbox.pop()
class MyQueue:
def __init__(self):
"""
Initialize your data structure here.
"""
# 初始化
self.stack1 = Stack()
self.stack2 = Stack()
def push(self, x):
"""
Push element x to the back of queue.
:type x: int
:rtype: void
"""
self.stack1.items.append(x)
def pop(self):
"""
Removes the element from in front of queue and returns that element.
:rtype: int
"""
if self.stack2.isEmpty() != True: #判断栈2是否为空
return self.stack2.items.pop()
else:
if self.stack1.isEmpty() != True:
while self.stack1.size() != 1:
self.stack2.items.append(self.stack1.items.pop())
return self.stack1.items.pop()
else:
if self.stack2.isEmpty() != True:
return self.stack2.items.pop()
def peek(self):
"""
Get the front element.
:rtype: int
"""
if self.stack2.isEmpty() != True:
if len(self.stack2.items) >= 1:
return self.stack2.items[len(self.stack2.items) - 1]
else:
if self.stack1.isEmpty() != True:
return self.stack1.items[0]
else:
return False
def empty(self):
"""
Returns whether the queue is empty.
:rtype: bool
"""
return self.stack1.items == [] and self.stack2.items == []
def size(self):
return len(self.stack1.items) + len(self.stack2.items)
def eval_expr(expr):
s = Stack()
for token in expr.split():
if token in ['+', '-', '*', '/', '//', '%', '**']:
if s.size() < 2:
raise IndexError("Empty Stack, too few operands.")
else:
op2 = s.pop()
op1 = s.pop()
result = do_math(op1, op2, token)
s.push(result)
elif token == '=':
if s.size() > 1:
raise IndexError("Stack is not empty, too many operands.")
else:
return s.pop()
# Unknown operator was not on the assignment but I accounted for it.
# E.g. '?' would be seen as an unknown operator in any expression.
elif token not in ['+', '-', '*', '/', '//', '%', '**', '='
] and not token.isdigit():
raise ValueError("Invalid operator.")
else:
s.push(int(token))
def huffman_decoding(data, tree):
x = 0
root = tree.root
decoder_stack = Stack()
decoded_word = ""
while x < len(data):
if data[x] == "0":
decoder_stack.push(root)
root = root.left
elif data[x] == "1":
decoder_stack.push(root)
root = root.right
if root.data != 0:
decoded_word += root.data
while decoder_stack.size() != 0:
root = decoder_stack.pop()
x += 1
return decoded_word
def rpn_calc():
postfixExpr = input(
"Please enter an expression in Reverse Polish notation: ")
operandStack = Stack()
tokenList = postfixExpr.split()
for token in tokenList:
if token in "0123456789":
operandStack.push(int(token))
else:
operand2 = operandStack.pop()
operand1 = operandStack.pop()
result = doMath(token, operand1, operand2)
operandStack.push(result)
if operandStack.size() > 1:
raise Exception("The expression is invalid.")
return operandStack.pop()
# 设置长度
if last_disk_size != None:
length = last_disk_size[0] - 1
if length <= 0:
length = 1
for i in self.items:
i.resizemode('user')
i.shapesize(i.shapesize()[0] + 1, 0.5)
item.shapesize(*(length, last_disk_size[1]))
# 海龟位置y坐标
index = len(self.items) - 1
item_y = 20 * 0.5 / 2 + index * 20 * 0.5 + self.y
# 海龟就位
self.items[index]: Disk.penup()
self.items[index].goto(self.x, item_y)
Stack.push = push
Stack.__str__ = __str__
screen = turtle.Screen()
from_stack = Stack('From Stack', -300, -150)
for i in range(6):
from_stack.push(Disk(0))
assist_satck = Stack('Assist Satck', 0, 100)
to_stack = Stack('To Stack', 300, -150)
hanoi(from_stack.size(), from_stack, assist_satck, to_stack)
screen.mainloop()
