def build_parse_tree(fp_exp):
fp_list = fp_exp.split()
p_stack = Stack()
e_tree = BinaryTree('')
p_stack.push(e_tree)
current_tree = e_tree
for i in fp_list:
if i == '(':
current_tree.insert_left('')
p_stack.push(current_tree)
current_tree = current_tree.get_left_child()
elif i not in ['+', '-', '*', '/', ')']:
current_tree.set_root_val(int(i))
parent = p_stack.pop()
current_tree = parent
elif i in ['+', '-', '*', '/']:
current_tree.set_root_val(i)
current_tree.insert_right('')
p_stack.push(current_tree)
current_tree = current_tree.get_right_child()
elif i == ')':
current_tree = p_stack.pop()
else:
raise ValueError
return e_tree
class DFSGraph(Graph):
"""
depth first forest
Make dfs with every vertex in graph, the trees created are called depth first forest.
"""
def __init__(self):
super().__init__()
self.time = 0
self.finish = 0
self.finish_stack = Stack()
def dfs(self, start_vertex):
"""
dfs use stack to keep track of vertex
:return:
"""
for vertex in self: # iterate over all vertices calling dfs_visit on vertex that are white, the reason to
# iterate over all vertices is that make sure all vertices are considered in the depth first forest
if vertex.color == 'white':
self.dfs_visit(vertex)
def dfs_visit(self, start_vertex):
start_vertex.color = 'gray'
self.time += 1
start_vertex.discovery = self.time
for neighbor in start_vertex.get_neighbors():
if neighbor.color == 'white':
neighbor.predecessor = start_vertex
self.dfs_visit(neighbor)
start_vertex.color = 'black' # set current vertex to black if it does not have neighbors
self.time += 1
start_vertex.finish = self.time
self.finish_stack.push(start_vertex)
def build_parse_tree(fp_exp):
fp_list = fp_exp.split()
p_stack = Stack()
e_tree = BinaryTree('')
p_stack.push(e_tree)
current_tree = e_tree
for i in fp_list:
if i == '(':
current_tree.insert_left('')
p_stack.push(current_tree)
current_tree = current_tree.get_left_child()
elif i not in ['+', '-', '*', '/', ')']:
current_tree.set_root_val(int(i))
parent = p_stack.pop()
current_tree = parent
elif i in ['+', '-', '*', '/']:
current_tree.set_root_val(i)
current_tree.insert_right('')
p_stack.push(current_tree)
current_tree = current_tree.get_right_child()
elif i == ')':
current_tree = p_stack.pop()
else:
raise ValueError
return e_tree
class StrongConnectedComponent:
def __init__(self, g):
self.g = g
self.rg = None
self.s = Stack()
self.visited = set()
def scc(self):
# First DFS
for key in self.g.get_vertices():
if key not in self.visited:
self.dfs(key)
# reverse graph
self.rg = g.reverse()
# Second DFS based on stack
self.visited.clear()
result = list()
while not self.s.is_empty():
start_vertex = self.s.pop()
if start_vertex not in self.visited:
ssc = set()
self.dfs_reverse(start_vertex, ssc)
result.append(ssc)
return result
def dfs(self, vertex):
"""
DFS for first graph dfs
:param vertex:
:return:
"""
self.visited.add(vertex)
for neighbor in self.g.get_vertex(vertex).get_neighbors():
if neighbor.get_key() not in self.visited:
self.dfs(neighbor.get_key())
self.s.push(vertex)
def dfs_reverse(self, vertex, ssc):
"""
DFS for reverse graph
:param vertex:
:param ssc:
:return:
"""
self.visited.add(vertex)
ssc.add(vertex)
for neighbor in self.rg.get_vertex(vertex).get_neighbors():
if neighbor.get_key() not in self.visited:
self.dfs_reverse(neighbor.get_key(), ssc)
def __init__(self, g):
self.g = g
self.rg = None
self.s = Stack()
self.visited = set()
def __init__(self):
self.queue = Stack()
self.buffer = Stack()
class DoubleStackQueue:
def __init__(self):
self.queue = Stack()
self.buffer = Stack()
def enqueue(self, item):
self.buffer.push(item)
def dequeue(self):
while self.buffer.size() > 0:
self.queue.push(self.buffer.pop())
val = self.queue.pop() if self.queue else None
while self.queue.size() > 0:
self.buffer.push(self.queue.pop())
return val
def size(self):
return self.buffer.size()
def __init__(self):
super().__init__()
self.time = 0
self.finish = 0
self.finish_stack = Stack()
from List.Node import Node
from Stack.Stack import Stack
print(Stack())
print(Node('hh'))
from Stack.Stack import Stack
if __name__ == '__main__':
stack = Stack()
stack.push(32)
print(stack.pop()) # print top most element of stack.
def setUp(self):
self.stack = Stack()
class TestStack(unittest.TestCase):
def setUp(self):
self.stack = Stack()
def test_stack_init(self):
self.assertEqual(0, self.stack.length())
def test_stack_push(self):
self.stack.push(5)
self.assertEqual(1, self.stack.length())
def test_stack_pop(self):
self.stack.push(5)
self.stack.push(10)
self.assertEqual(10, self.stack.pop())
self.assertEqual(5, self.stack.pop())
self.assertEqual(0, self.stack.length())
def test_cannot_pop_from_empty_stack(self):
with self.assertRaises(StackEmptyException):
self.stack.pop()
def test_is_stack_empty_returns_true_for_empty_stack(self):
self.assertEqual(True, self.stack.is_empty())
class Queue:
"""
An implementation of Queue with two Stacks
"""
def __init__(self):
self.__in_stack = Stack()
self.__out_stack = Stack()
def length(self):
return self.__in_stack.length() + self.__out_stack.length()
def enqueue(self, item):
self.__in_stack.push(item)
def is_empty(self):
return self.__out_stack.is_empty() and self.__in_stack.is_empty()
def dequeue(self):
if self.is_empty():
raise QueueEmptyException('Queue is empty')
if self.__out_stack.is_empty():
self._re_fill_out_stack()
return self.__out_stack.pop()
def _re_fill_out_stack(self):
while self.__in_stack.length():
self.__out_stack.push(self.__in_stack.pop())
def __init__(self):
self.__in_stack = Stack()
self.__out_stack = Stack()