def topoSort(chart):
stack = LinkedStack()
chart.clearVertexMarks()
for v in chart.vertices():
if not v.isMarked():
dfs(chart, v, stack)
return stack
def queue_to_stack(my_queue):
q = deepcopy(my_queue)
s = LinkedStack()
while not q.isEmpty():
s.add(q.peek())
q.pop()
return s
def convert(self):
# cache the result
if not self._pfTokens:
# save the converted expression (tokens)
self._pfTokens = []
# stack to store operators and operands
stack = LinkedStack()
for token in self._scanner:
# append the operand to list
if not token.isOperator():
self._pfTokens.append(token)
# Token.OPENPAREN & Token.CLOSEPAREN are operators,
# so must be called before token.isOperator().
elif token.getType() == Token.OPENPAREN:
stack.push(token)
elif token.getType() == Token.CLOSEPAREN:
for i in range(len(stack)):
operator = stack.pop()
if operator.getType() == Token.OPENPAREN:
break
self._pfTokens.append(operator)
elif token.isOperator():
# pop operators in the stack whose precedence is not smaller
for i in range(len(stack)):
if (stack.peek().getType() == Token.OPENPAREN
or stack.peek().getPrecedence() <
token.getPrecedence()):
break
self._pfTokens.append(stack.pop())
stack.push(token)
for i in range(len(stack)):
self._pfTokens.append(stack.pop())
return self._pfTokens
def topo_sort(g, start_label=None):
stack = LinkedStack()
g.clear_vertex_marks()
for v in g.vertices():
if not v.is_marked():
dfs(g, v, stack)
return stack
def topoSort(g, startLabel=None):
stack = LinkedStack()
g.clearVertexMarks()
for v in g.vertices():
if not v.isMarked():
dfs(g, v, stack)
return stack
def test_linkedstack_pop_returnselement(self):
stack = LinkedStack()
for i in range(10):
stack.push(i + 1)
for i in range(10):
val = stack.pop()
assert_equal(10 - i, val)
assert_equal(10 - i - 1, len(stack))
def test_push_to_stack(self):
name = "Jose"
node = Node(name)
stack = LinkedStack()
stack.push(node)
self.assertEqual(len(stack), 1)
def _is_palindrom(word):
ls = LinkedStack()
for i in range(len(word) // 2):
ls.add(word[i])
md = len(word) // 2 if len(word) % 2 == 0 else len(word) // 2 + 1
for i in range(md, len(word)):
if ls.pop() != word[i]:
return False
return True
def _is_palindrom(word):
ls = LinkedStack()
for i, c in enumerate(word):
if i < len(word) // 2:
ls.push(c)
elif i >= (len(word) - 1) // 2 + 1:
if c != ls.pop():
return False
return True
def is_palindrome(word):
stack = LinkedStack()
for index in range(len(word) // 2):
stack.push(word[index])
for index in range((len(word) + 1) // 2, len(word)):
if stack.peek() == word[index]:
stack.pop()
else:
return False
return True
def node_preorder(self):
if not self.isEmpty():
stack = LinkedStack()
stack.push(self._root)
while not stack.isEmpty():
node = stack.pop()
yield node
if node.right != None:
stack.push(node.right)
if node.left != None:
stack.push(node.left)
def traverseFromVertex(graph, startVertex, process, collection=LinkedStack()):
chart.clearVertexMarks()
collection.add(startVertex)
while not collection.isEmpty():
v = collection.pop()
if not v.isMarked():
v.setMark()
process(v)
for vertex in v.neighboringVertices():
if not vertex.isMarked():
collection.add(vertex)
def preorder(self):
"""Supports a preorder traversal on a view of self."""
if not self.isEmpty():
treeStack = LinkedStack()
treeStack.push(self._root)
while not treeStack.isEmpty():
node = treeStack.pop()
yield node.data
if node.right != None:
treeStack.push(node.right)
if node.left != None:
treeStack.push(node.left)
def brackets_Checker():
stk = LinkedStack()
for ch in exp:
if ch in ['[', '(']:
stk.push(ch)
elif ch in [']', ')']:
if stk.isEmpty():
return False
chFromStack = stk.pop()
if ch == ']' and chFromStack != '[' or ch == ')' and chFromStack != '(':
return False
return stk.isEmpty()
def queue_to_stack(queue):
"""Return a stack that contains items from the queue."""
stack = LinkedStack()
item_list = []
for item in queue:
item_list.insert(0, item)
for item in item_list:
stack.push(item)
return stack
def __iter__(self):
"""Supports a preorder traversal on a view of self."""
if not self.isEmpty():
stack = LinkedStack()
stack.push(self._root)
while not stack.isEmpty():
node = stack.pop()
yield node.data
if node.right is not None:
stack.push(node.right)
if node.left is not None:
stack.push(node.left)
def successor(self, item):
"""
Returns the smallest item that is larger than
item, or None if there is no such item.
:param item:
:type item:
:return:
:rtype:
"""
biggest = 0
if not self.isEmpty():
stack = LinkedStack()
stack.push(self._root)
while not stack.isEmpty():
node = stack.pop()
# print(smallest, node.data)
if node.data >= biggest:
biggest = node.data
if node.right != None:
stack.push(node.right)
if node.left != None:
stack.push(node.left)
smallest = biggest
# print(smallest)
if not self.isEmpty():
stack = LinkedStack()
stack.push(self._root)
while not stack.isEmpty():
node = stack.pop()
# print(smallest, node.data)
if item <= node.data <= smallest:
smallest = node.data
if node.right != None:
stack.push(node.right)
if node.left != None:
stack.push(node.left)
# print(smallest)
return smallest if smallest != 0 else None
def test_pop_from_stack(self):
name = "Jose"
node = Node(name)
stack = LinkedStack()
stack.push(node)
self.assertEqual(len(stack), 1)
popped = stack.pop()
self.assertEqual(popped, node)
self.assertEqual(len(stack), 0)
def bracketsBalance(exp):
"""exp is s string that represents the expression"""
stk = LinkedStack()
for ch in exp:
if ch in ["[", "("]:
stk.push(ch)
elif ch in [']', ')']:
if stk.isEmpty():
return False
chFromStck = stk.pop()
if ch == ']' and chFromStck != '[' or \
ch == ')' and chFromStck != '(' :
return False
return stk.isEmpty()
def bracketsBalance(exp):
"""exp is a string that represents the expression """
stk = LinkedStack()
for ch in exp:
if ch in ['[', '(']:
stk.push(ch)
elif ch in [']', ')']:
if stk.isEmpty():
return False
chFromStack = stk.pop()
# Brackets must be of same type and match up
if ch == ']' and chFromStack != '[' or ch == ')' and chFromStack != '(':
return False
return stk.isEmpty()
def operate(self):
'''Operate the postfix expression.'''
stack = LinkedStack()
for operand in self._tokens:
if operand not in PostfixExpression._operator:
# push the operand to the stack
stack.push(operand)
else:
# operate two operand on the top of stack with the operation
opRight = float(stack.pop())
opLeft = float(stack.pop())
res = PostfixExpression._operator[operand](opLeft, opRight)
# push the result onto the stack
stack.push(res)
return stack.pop()
def bracketsBalance(exp):
"""exp represents the expression"""
stk = LinkedStack() # Create a new stack
for ch in exp: # Scan across the expression
if ch in ['[', '(']: # Push an opening bracket
stk.push(ch)
elif ch in [']', ')']: # Process a closing bracket
if stk.isEmpty(): # Not balanced
return False
chFromStack = stk.pop()
# Brackets must be of same type and match up
if ch == ']' and chFromStack != '[' or \
ch == ')' and chFromStack != '(':
return False
return stk.isEmpty() # They all matched up
def levelorder(self):
"""Supports a levelorder traversal on a view of self."""
if not self.isEmpty():
stack = LinkedStack()
stack.push(self.root)
yield self.root.data
while not stack.isEmpty():
node = stack.pop()
if node.left != None:
yield node.left.data
stack.push(node.right)
if node.right != None:
yield node.right.data
stack.push(node.left)
def mazeSolver(maze, start, to_text=False, data_structure='stack'):
"""takes a maze and its starting point (as a tuple of row, column) and solves the maze. Maze walls must be *
characters and the ending point must be a "T" character. Free spaces must be an empty space, " ". """
# read the grid and set up stack
grid = maze_reader(maze)
print("maze without attempts:\n", grid)
if data_structure == 'stack':
_queue = LinkedStack()
else:
_queue = LinkedQueue(
) #TODO implement a linkedQueue structure with push
_queue.push(start)
# track choices:
choice_count = 0
#use stack data structure to explore maze and find a path to the end.
while not _queue.isEmpty():
_pop = _queue.pop()
# print("popping ",_pop)
if grid[_pop[0]][_pop[1]] == 'T':
choice_count += 1
print("Finished maze: \n")
print(grid)
if to_text:
maze_text(grid, "solution.txt")
return choice_count
else:
# if the _pop location did not return the character "T", leave a breadcrumb to not revisit.
if grid[_pop[0]][_pop[1]] != 'O' and grid[_pop[0]][
_pop[1]] != 'T' and grid[_pop[0]][_pop[1]] != 'P':
choice_count += 1
grid[_pop[0]][_pop[1]] = 'O'
# print("grid row, column is ",_pop[0],_pop[1],"\n")
# print(grid)
left = grid[_pop[0]][(_pop[1] - 1)]
right = grid[_pop[0]][(_pop[1] + 1)]
down = grid[(_pop[0] - 1)][_pop[1]]
up = grid[(_pop[0] + 1)][_pop[1]]
if left == ' ' or left == 'T':
_queue.push((_pop[0], (_pop[1] - 1)))
if right == ' ' or right == 'T':
_queue.push((_pop[0], (_pop[1] + 1)))
if up == ' ' or up == 'T':
_queue.push(((_pop[0] + 1), _pop[1]))
if down == ' ' or down == 'T':
_queue.push(((_pop[0] - 1), _pop[1]))
#if stack becomes empty, there is no path.
return choice_count
def isPalindrome(word: str) -> bool:
'''
True if a word read from left equal to from right else False.
'''
wordLen = len(word)
if wordLen == 1 or wordLen == 0:
return True
stack = LinkedStack()
middle = wordLen // 2
for index in range(0, middle):
stack.push(word[index])
for index in range(wordLen - middle, wordLen):
if word[index] != stack.pop():
return False
return True
def height(self):
hgt = LinkedStack()
def recurse(node, count):
if node != None:
if count > hgt.peek():
hgt.push(hgt.pop() + 1)
recurse(node.left, count + 1)
recurse(node.right, count + 1)
if self.isEmpty():
return None
else:
hgt.push(-1)
recurse(self.root, 0)
return hgt.pop()
def is_palindrome(word: str) -> bool:
"""Check whether the word is a palindrome."""
stack = LinkedStack()
for index, char in enumerate(word, 1):
if char.isalpha() and index <= len(word) / 2:
stack.push(char)
elif char.isalpha() and (index > len(word) / 2) \
and (index != (len(word) / 2) + 0.5):
if stack.isEmpty():
return False
char_from_stack = stack.pop()
if char != char_from_stack:
return False
return stack.isEmpty()
def is_palindrome(self, word):
# check if word is palindrome
half_1, half_2 = word[:len(word) // 2], word[len(word) // 2:]
# cut first letter, whcih is not important
if len(half_2) != len(half_1):
half_2 = half_2[1:]
stack = LinkedStack()
for let in half_1:
stack.push(let)
for i in range(len(half_2)):
if half_2[i] != stack.peek():
return 0
stack.pop()
return 1
def predecessor(self, item):
pred = LinkedStack()
def recurse(node, item):
if node != None:
if item <= node.data:
recurse(node.left, item)
elif item > node.data:
pred.push(node.data)
recurse(node.right, item)
if self.isEmpty():
return None
else:
recurse(self.root, item)
result = None
if not pred.isEmpty():
result = pred.pop()
return result
def successor(self, item): #FIXME: Incomplete
succ = LinkedStack()
def recurse(node, item):
if node != None:
if item >= node.data:
recurse(node.right, item)
elif item < node.data:
succ.push(node.data)
recurse(node.left, item)
if self.isEmpty():
return None
else:
recurse(self.root, item)
result = None
if not succ.isEmpty():
result = succ.pop()
return result
