class QueueUsingStack(object):
def __init__(self):
self._stack_one = Stack()
self._stack_two = Stack()
def __str__(self):
return self._stack_one.__str__()
def enqueue(self, element):
'''
:param element: element to be enqueued in the queue
'''
while not self._stack_one.is_empty():
self._stack_two.push(self._stack_one.pop())
self._stack_one.push(element)
while not self._stack_two.is_empty():
self._stack_one.push(self._stack_two.pop())
return
def dequeue(self):
if self._stack_one.is_empty():
raise UnderflowException
return self._stack_one.pop()
def stack_span(prices):
st = Stack()
nelements = len(prices)
span = [0] * nelements
for i in range(nelements):
while not (st.is_empty()) and prices[st.top()] <= prices[i]:
_ = st.pop()
span[i] = i + 1 if st.is_empty() else i - st.top()
st.push(i)
return span
class TestStack(unittest.TestCase):
def setUp(self) -> None:
self.st = Stack()
def test_is_empty(self):
self.assertTrue(self.st.is_empty(), "The stack is not empty")
self.assertRaises(IndexError, self.st.pop)
def test_repr(self):
self.assertEqual("Stack()", repr(self.st), "The repr method does not work properly")
def test_push_one_item(self):
self.st.push(2)
self.assertFalse(self.st.is_empty())
self.assertEqual("Stack(2)", str(self.st))
def test_push_multiple_items(self):
self.st.push(3)
self.st.push(10)
self.assertEqual("Stack(3, 10)", str(self.st))
popped_item = self.st.pop()
self.assertEqual(10, popped_item)
def test_is_full(self):
for i in range(10):
self.st.push(i)
self.assertTrue(self.st.is_full())
self.assertRaises(OverflowError, self.st.push, 12)
def test_pop_one_item(self):
self.st.push(3)
popped_item = self.st.pop()
self.assertEqual(3, popped_item)
def test_pop_multiple_items(self):
self.st.push(3)
self.st.push(10)
popped_item = self.st.pop()
self.assertEqual(10, popped_item)
popped_item = self.st.pop()
self.assertEqual(3, popped_item)
def test_type(self):
self.assertRaises(TypeError, self.st.push, "3")
self.assertRaises(TypeError, self.st.push, 3.1)
self.assertRaises(TypeError, self.st.push, True)
def test_top_non_empty_stack(self):
self.st.push(3)
self.st.push(10)
self.assertEqual(10, self.st.top())
def test_top_empty_stack(self):
self.assertRaises(IndexError, self.st.top)
def pre_order_not_recursion(self):
pre_order_list = []
node = self
s = Stack()
while node or not s.is_empty():
while node:
pre_order_list.append(node)
s.push(node)
node = node.left
if not s.is_empty():
node = (s.pop()).right
return pre_order_list
def in_order_not_recursion(self):
in_order_list = []
node = self
s = Stack()
while node or not s.is_empty():
while node:
s.push(node)
node = node.left
if not s.is_empty():
node = s.pop()
in_order_list.append(node)
node = node.right
return in_order_list
def reverse_string(input_string):
s = Stack()
for i in input_string:
s.push(i)
rev_string = ''
while not s.is_empty():
rev_string = rev_string + (s.pop())
return rev_string
def test_push_five_elements_to_stack_and_pop_all_elements(self):
stack = Stack()
langs = ['python', 'java', 'ruby', 'php', 'go']
for lang in langs:
stack.push(lang)
self.assertEqual(len(langs), stack.size())
for i in range(len(langs)):
element = stack.pop()
self.assertEqual(element, langs[len(langs) - i - 1])
self.assertTrue(stack.is_empty())
def pre_order_traverse(root):
""" please refer to http://learn.hackerearth.com/tutorial/trees/19/iterative-tree-traversals/
"""
stack = Stack()
p = root
while True:
while p is not None:
# print node and store the node in the stack
print p,
stack.push(p)
p = p.lchild
# visit the right child
if not stack.is_empty():
p = stack.pop()
p = p.rchild
if stack.is_empty() and p is None:
break
print
def in_order_traverse(root):
""" please refer to http://learn.hackerearth.com/tutorial/trees/19/iterative-tree-traversals/
"""
stack = Stack()
p = root
while True:
while p is not None:
# store a node in the stack and visit its left child
stack.push(p)
p = p.lchild
# if there are nodes in the stack to which we can move up, then pop it
if not stack.is_empty():
p = stack.pop()
print p,
# visit the right child
p = p.rchild
if stack.is_empty() and p is None:
break
print
def infix2postfix(infix):
s = Stack()
l = []
linfix = infix.split()
priority = {"*": 3, "/": 3, "+": 2, "-": 2, "(": 1}
for i in linfix:
if i == "(":
s.push(i)
elif i == ")":
t = s.pop()
while not s.is_empty() and t != "(":
l.append(t)
t = s.pop()
elif i in "+-*/":
while not s.is_empty() and priority[s.peek()] >= priority[i]:
l.append(s.pop())
s.push(i)
else:
l.append(i)
while not s.is_empty():
l.append(s.pop())
return " ".join(l)
def size(self):
if self.root is None:
return 0
stack = Stack()
stack.push(self.root)
size = 1
while not stack.is_empty():
node = stack.pop()
if node.left:
size += 1
stack.push(node.left)
if node.right:
size += 1
stack.push(node.right)
return size
def dfs_stack(root, fn):
stack = Stack()
stack.push(root)
visited = defaultdict(bool)
visited[root] = True
fn(root)
while not stack.is_empty():
node = stack.get_top()
for child in node.get_children():
if not visited.get(child):
fn(child)
visited[child] = True
stack.push(child)
else:
stack.pop()
class ParenthesisMatching(object):
def __init__(self, parenthesis):
self.parenthesis = parenthesis
self.stack = Stack()
def is_match(self):
maps = {")": "(", "]": "[", "}": "{"}
for p in self.parenthesis:
if p in "([{":
self.stack.push(p)
elif p in ")]}":
if self.stack.is_empty():
return False
else:
top = self.stack.pop()
if maps[p] != top:
return False
return True
def reverse_levelorder_print(self, start, traversal):
if start is None:
return
queue = Queue()
stack = Stack()
queue.enqueue(start)
while len(queue) > 0:
node = queue.dequeue()
stack.push(node)
if node.right:
queue.enqueue(node.right)
if node.left:
queue.enqueue(node.left)
while not stack.is_empty():
node = stack.pop()
traversal += str(node.value) + '-'
return traversal
class BitConversion(object):
def __init__(self, dec):
self.dec = dec
self.stack = Stack()
self.base = "0123456789abcdef"
def conversion(self, bit):
if bit not in (2, 8, 16):
raise ValueError("bit must in (2, 8, 16)")
while self.dec > 0:
remainder = self.dec % bit
self.stack.push(self.base[remainder])
self.dec = self.dec // bit
result = []
while not self.stack.is_empty():
result.append(self.stack.pop())
return "".join(result)
def is_paren_balanced(paren_string):
s = Stack()
index = 0
while index < len(paren_string):
paren = paren_string[index]
if paren in '{[(':
s.push(paren)
else:
if s.is_empty():
return False
else:
last_paren = s.pop()
if not is_match(last_paren, paren):
return False
index += 1
return True
def post_order_recursion(self):
post_order_list = []
node = self
pre_node = None
current_node = None
s = Stack()
s.push(node)
while not s.is_empty():
current_node = s.top()
if (not current_node.left and not current_node.right) or \
(pre_node and ((current_node.left and pre_node.key == current_node.left.key)
or (current_node.right and pre_node.key == current_node.right.key))):
post_order_list.append(current_node)
s.pop()
pre_node = current_node
else:
if current_node.right:
s.push(current_node.right)
if current_node.left:
s.push(current_node.left)
return post_order_list
def test_no_element_in_stack(self):
stack = Stack()
self.assertTrue(stack.is_empty())
