def isValidSource(srcFile):
"""
The function accepts a file object, which we assume was previously opened and contains C++
source code.The file is scanned one line at a time and each line is scanned one character
at a time to determine if it contains properly paired and balanced delimiters.
"""
s = Stack()
for line in srcFile:
for token in line:
if token in "{[(":
# if token is one of the opening delimiters it should be pushed
# into the stack.
s.push(token)
# if token is one of the closing delimiters it should be checke by
# the following steps.
elif token in ")]}":
if s.isEmpty():
return False
else:
left = s.pop()
if token == "}" and left != "{" or \
token == "]" and left != "[" or \
token == ")" and left != "(":
return False
return s.isEmpty()
class _BSTMapIterator:
""" Iterator for the binary search tree using a software stack """
def __init__(self, root):
"""Create a stack for use in traversing the tree. """
self._theStack = Stack()
self._traverseToMinNode(root)
def __iter__(self):
return self
def next(self):
"""Returns the next item from the BST in key order"""
# If the stack is empty, we are done.
if self._theStack.isEmpty():
raise StopIteration
else: # The top node on the stack contains the next key.
node = self._theStack.pop()
key = node.key
# If this node has a subtree rooted as the right child, we must
# find the node in that subtree that contains the smallest key.
# Again, the nodes along the path are pushed on the stack.
if node.right is not None:
self._traverseToMinNode(node.right)
return key
def _traverseToMinNode(self, subtree):
""" Traverses down the subtree to find the node containing the
smallest key during which the nodes along that path are pushed onto
the stack."""
if subtree is not None:
self._theStack.push(subtree)
self._traverseToMinNode(subtree.left)
def find_path(self):
stack = Stack()
current = self.startCell
current.path.append(current)
current.parent = current
if current == self.exitCell:
return True
home_cords_nei = self.check_neighbors(current.row, current.col)
for cell in home_cords_nei:
if cell == self.exitCell:
return True
cell.path.append(current)
stack.push(cell)
self.mark_tried(current.row, current.col)
while not stack.isEmpty():
parent = current
current = stack.peek()
current.parent = parent
current.path += parent.path
current.path.append(current)
self.mark_tried(current.row, current.col)
if self.exit_found(current.row, current.col):
self.exit = current
return True
stack.pop()
for cell in self.check_neighbors(current.row, current.col):
stack.push(cell)
return False
def findPath(self):
paths = Stack()
paths.push(self._startCell)
while not paths.isEmpty():
currCell = paths.pop()
self._markTried(currCell.row, currCell.col)
if currCell.row == self._exitCell.row and currCell.col == self._exitCell.col:
currCell.path.append(currCell)
for el in currCell.path:
self._markPath(el.row, el.col)
return True
if self._validMove(currCell.row + 1, currCell.col):
paths.push(
_CellPosition(currCell.row + 1, currCell.col, currCell))
if self._validMove(currCell.row - 1, currCell.col):
paths.push(
_CellPosition(currCell.row - 1, currCell.col, currCell))
if self._validMove(currCell.row, currCell.col + 1):
paths.push(
_CellPosition(currCell.row, currCell.col + 1, currCell))
if self._validMove(currCell.row, currCell.col - 1):
paths.push(
_CellPosition(currCell.row, currCell.col - 1, currCell))
return False
def isValidSource(srcfile):
s = Stack()
for line in srcfile:
for token in line:
if token in "{[(":
s.push(token)
elif token in "}])":
if s.isEmpty():
return False
else:
left = s.pop()
if (token == "}" and left != "{") or \
(token == "]" and left != "[") or \
(token == ")" and left != "("):
return False
return s.isEmpty()
def findPath( self ):
traceAcct = Stack()
curPos = _CellPosition(self._startCell.row, self._startCell.col)
if not self._validMove(curPos.row, curPos.col):
return False
self._markPath(curPos.row, curPos.col)
trapFlag = False
while True:
for i in range(4): # Left, Up, Right, Down
candidatePos = _CellPosition(curPos.row + self.DIRECT[i][0], \
curPos.col + self.DIRECT[i][1])
if self._validMove(candidatePos.row, candidatePos.col):
traceAcct.push(curPos)
curPos = candidatePos
self._markPath(curPos.row, curPos.col)
if self._exitFound(curPos.row, curPos.col):
return True
break
if i == 3:
trapFlag = True
continue
if trapFlag:
trapFlag = False
self._markTried(curPos.row, curPos.col)
if traceAcct.isEmpty():
return False
else:
curPos = traceAcct.pop()
def findPath(self):
s = Stack() #stack to save the path
s.push(self._startCell)
self._markPath(self._startCell.row, self._startCell.col)
while True:
#inside the loop where neighbor cell is checked for valid move
#same time, checked if we get the exit
if s.isEmpty():
return False
current_cell = s.peek()
row = current_cell.row
col = current_cell.col
if not self._exitFound(row, col):
for r in [row - 1, row, row + 1]:
if not (current_cell.row == s.peek().row and \
current_cell.col == s.peek().col):
break
for c in [col - 1, col, col + 1]:
if ((r == row) ^ (c == col)):
if self._validMove(r, c):
self._markPath(r, c)
s.push(_CellPosition(r, c))
break
if current_cell.row == s.peek().row and\
current_cell.col == s.peek().col:
not_in_path = s.pop()
self._markTried(not_in_path.row, not_in_path.col)
else:
return True
def findPath(self):
"""
finds path in a Maze and Returns True
if no path it will return None
"""
maze_stack = Stack()
maze_stack.push(self._startCell)
current_cell = self._startCell
self._markPath(self._startCell.row, self._startCell.col)
while not maze_stack.isEmpty():
possible_moves = [(-1, 0), (0, 1), (1, 0), (0, -1)]
current_cell.row = maze_stack.peek().row
current_cell.col = maze_stack.peek().col
self._markPath(current_cell.row, current_cell.col)
moved = False
for i, j in possible_moves:
if self._validMove(current_cell.row + i, current_cell.col + j):
current_cell.row = current_cell.row + i
current_cell.col = current_cell.col + j
maze_stack.push(
_CellPosition(current_cell.row, current_cell.col))
moved = True
break
if moved:
if self._exitFound(current_cell.row, current_cell.col):
self._markPath(current_cell.row, current_cell.col)
return True
continue
visited_cell = maze_stack.pop()
self._markTried(visited_cell.row, visited_cell.col)
class _BSTMapIterator:
def __init__(self, root):
# Creates a stack for use in traversing the tree.
self._theStack = Stack()
self._traverseToMinNode(root)
def __iter__(self):
return self
# Returns the next item from the BST in key order.
def __next__(self):
# If the stack is empty, we are done.
if self._theStack.isEmpty():
raise StopIteration
else:
# The top node on the stack contains the next key.
node = self._theStack.pop()
key = node.key
# If this node has a subtree rooted as the right child, we must
# find the node in that subtree that contains the smallest key.
# Again, the nodes along the path are pushed onto the stack.
if node.right is not None:
self._traverseToMinNode(node.right)
return key
# Traverses down the subtree to find the node containing the smallest
# key during which the nodes along that path are pushed onto the stack.
def _traverseToMinNode(self, subtree):
if subtree is not None:
self._theStack.push(subtree)
self._traverseToMinNode(subtree.left)
class _BSTMapIterator:
def __init__( self, root ):
self._theStack = Stack()
# traverse down to the node containing the smallest key during
# which each node along the path is pushed onto the stack
self._traverseToMinNode( root )
def __iter__( self ):
return self
# Returns the next item from the BST in key order.
def next( self ):
# If the stack is empty, we are done..
if self._theStack.isEmpty():
raise StopIteration
else:
# The top node on the stack contains the key.
node = self._theStack.pop()
key = node.key
# If this node has a subtree rooted as the right child, we must
# fiind the node in that subtree that contains the smallest key.
# Again, the nodes along the path are pushed onto the stack.
if node.right is not None:
self._traverseToMinNode( node.right )
return key
def _traverseToMinNode( self, subtree ):
if subtree is not None:
self._theStack.push( subtree )
self._traverseToMinNode( subtree.left )
class _T23Iter:
""" Iterator for the 2-3 tree using a software stack """
FIRST_KEY = 0
SECOND_KEY = 1
LEFT_BRANCH = 0
MID_BRANCH = 1
RIGHT_BRANCH = 2
def __init__(self, root):
"""Create a stack for use in traversing the tree. """
self._theStack = Stack()
if root is not None:
self._theStack.push((root, _T23Iter.FIRST_KEY))
self._traverseToMinNode(root, _T23Iter.LEFT_BRANCH)
def __iter__(self):
return self
def next(self):
"""Returns the next item from the BST in key order"""
# If the stack is empty, we are done.
if self._theStack.isEmpty():
raise StopIteration
else: # The top node on the stack contains the next key.
(node, which) = self._theStack.pop()
if node.isLeaf() and which == _T23Iter.FIRST_KEY:
key = node.key1
if node.isFull():
self._theStack.push((node, _T23Iter.SECOND_KEY))
elif node.isLeaf() and which == _T23Iter.SECOND_KEY:
key = node.key2
elif not node.isLeaf() and which == _T23Iter.FIRST_KEY:
key = node.key1
if node.isFull():
self._theStack.push((node, _T23Iter.SECOND_KEY))
self._traverseToMinNode(node, _T23Iter.MID_BRANCH)
else: # not node.isLeaf() and which == _T23Iter.SECOND_KEY:
key = node.key2
self._traverseToMinNode(node, _T23Iter.RIGHT_BRANCH)
return key
def _traverseToMinNode(self, node, branch):
""" Traverses down <node>'s branch indecated by <branch> to find
the node containing the in-order successor"""
if not node.isLeaf():
if branch == _T23Iter.LEFT_BRANCH:
node = node.left
elif branch == _T23Iter.MID_BRANCH:
node = node.middle
else: # branch == _T23Iter.RIGHT_BRANCH
node = node.right
self._theStack.push((node, _T23Iter.FIRST_KEY))
while not node.isLeaf():
node = node.left
self._theStack.push((node, _T23Iter.FIRST_KEY))
def printListStack(head):
s = Stack()
curNode = head
while curNode is not None:
s.push(curNode.data)
curNode = curNode.next
while not s.isEmpty():
item = s.pop()
print item
def printListStack(head): s = Stack() curNode = head while curNode is not None: s.push(curNode.data) curNode = curNode.next while not s.isEmpty(): item = s.pop() print item
class ExtoPostfix:
"""
Receive an infix expression and turn it into a postfix expression.
This is a helper module of postfixCal.py.
"""
def __init__(self):
self._isp = {'#':0, '(':1, '*':5, '/':5, '+':3, '-':3, ')':6} #in stack priority
self._icp = {'#':0, '(':6, '*':4, '/':4, '+':2, '-':2, ')':1} #in coming priority
self._postfix = [] #the list used to save the final postfix expression.
self._oprtStack = Stack() #the stack used to change the order of operators.
def __str__(self):
self._postfix = [elem for elem in self._postfix if elem != ')' and elem != '(']
return ','.join(self._postfix)
def _getPostfix(self,expr):
"""
Algorithm:
1)initialize the _oprtStack by pushing '#' into it.
2)read in the first element of the infix expr, and assign it to variable ch.
3)repeat the following steps until ch = '#', meanwhile, the top element of the _oprtStack is also '#':
a)if ch is operand, append it to the _postfix, and read the next ch;
b)if ch is operator, compare the priority(icp) of ch and the priority(isp) of the top element(op) in _oprtStack:
if icp(ch) > isp(op), push ch onto _oprtStack, and read another ch
if icp(ch) < isp(op), pop the top element in _oprtStack, and append it to _postfix
if icp(ch) == isp(op), pop the top element in _oprtStack,if op is '(', read another ch.
"""
expr = expr.split()
self._oprtStack.push('#')
ch = expr.pop(0)
while self._oprtStack.isEmpty()==False and ch != '#':
if ch.isdigit():
self._postfix.append(ch)
ch = expr.pop(0)
else:
ch1 = self._oprtStack.peek()
if self._isp[ch1] < self._icp[ch]:
self._oprtStack.push(ch)
ch = expr.pop(0)
elif self._isp[ch1] > self._icp[ch]:
out = self._oprtStack.pop()
self._postfix.append(out)
else:
out = self._oprtStack.pop()
if out == '(':
ch = expr.pop(0)
for i in range(len(self._oprtStack)-1):
ch1 = self._oprtStack.pop()
self._postfix.append(ch1)
def backExpr(self,expr):
self._getPostfix(expr)
return self._postfix
def findPath( self ):
stack = Stack()
self._markPath(self._startCell.row, self._startCell.col)
stack.push(self._startCell)
while not stack.isEmpty():
# debug
stack.show()
cur = _CellPosition(0, 0)
cur.row = stack.peek().row
cur.col = stack.peek().col
print "current:"
print (cur.row, cur.col)
if cur.row == self._exitCell.row and \
cur.col == self._exitCell.col:
print "findPath ok"
return 1
if self.haveUp(cur.row, cur.col):
cur.row = cur.row - 1
stack.push(cur)
self._markPath(cur.row, cur.col)
continue
if self.haveRight(cur.row, cur.col):
cur.col = cur.col + 1
stack.push(cur)
self._markPath(cur.row, cur.col)
continue
if self.haveDown(cur.row, cur.col):
cur.row = cur.row + 1
stack.push(cur)
self._markPath(cur.row, cur.col)
continue
if self.haveLeft(cur.row, cur.col):
cur.col = cur.col - 1
stack.push(cur)
self._markPath(cur.row, cur.col)
continue
print "aaaaaaaaaaaaa"
self._markTried(cur.row, cur.col)
stack.pop()
stack.show()
print "findPath fail"
return 0
def printListStack(head):
# Createe a stack to store the items
s = Stack()
# Iterate throught the list and push each item onto the stack
curNode = head
while curNode is not None:
s.push(curNode.data)
curNode = curNode.next
# Repeatedly pop the items from the stack and print them until the stack is empty
while not s.isEmpty():
item = s.pop()
print item
def printListStack( head ):
from lliststack import Stack
s = Stack()
# Iterate through the list and push each item onto the stack
curNode = head
while curNode is not None:
s.push( curNode.data )
curNode = curNode.next
# Repeatedly pop the items from the stack and print them
while not s.isEmpty():
item = s.pop()
print item,
print ''
def find_path(self):
if not self.maze_cells[self.exit_cell.row, self.exit_cell.col] is None:
return False
tmp = Stack()
i, j = self.start_cell.row, self.start_cell.col
dead_ends = [self.CELL_PATH, self.CELL_TRIED, self.CELL_WALL]
directions = [(1, 0), (0, 1), (-1, 0), (0, -1)]
tmp.push([i, j])
self.maze_cells[i, j] = self.CELL_PATH
while True:
for direction in directions:
try:
i1, j1 = i + direction[0], j + direction[1]
t = self.maze_cells[i1, j1]
except IndexError:
continue
while self.maze_cells[i1, j1] \
not in dead_ends:
i += direction[0]
j += direction[1]
tmp.push([i, j])
self.maze_cells[i, j] = self.CELL_PATH
if i == self.exit_cell.row and j == self.exit_cell.col:
return True
if i == self.start_cell.row and j == self.start_cell.col:
return False
if self.check_cell(i, j) is None:
while True:
coor = tmp.pop()
if tmp.isEmpty():
return False
self.maze_cells[coor[0], coor[1]] = self.CELL_TRIED
coor = tmp.peek()
tmpcoor = self.check_cell(coor[0], coor[1])
if tmpcoor:
i, j = coor[0], coor[1]
break
if i == self.start_cell.row and j == self.start_cell.col:
return False
if i == self.exit_cell.row and j == self.exit_cell.col:
return True
def findPath(self):
stack_path = Stack()
stack_path.push(self._startCell)
while not stack_path.isEmpty():
use_cell = stack_path.pop()
self._markTried(use_cell.row, use_cell.col)
if use_cell.row == self._exitCell.row and use_cell.col == self._exitCell.col:
use_cell.path.append(use_cell)
for i in use_cell.path:
self._markPath(i.row, i.col)
return True
if self._validMove(use_cell.row + 1, use_cell.col):
stack_path.push(
_CellPosition(use_cell.row + 1, use_cell.col, use_cell))
if self._validMove(use_cell.row - 1, use_cell.col):
stack_path.push(
_CellPosition(use_cell.row - 1, use_cell.col, use_cell))
if self._validMove(use_cell.row, use_cell.col + 1):
stack_path.push(
_CellPosition(use_cell.row, use_cell.col + 1, use_cell))
if self._validMove(use_cell.row, use_cell.col - 1):
stack_path.push(
_CellPosition(use_cell.row, use_cell.col - 1, use_cell))
return False
# Test the Stack
#from liststack import Stack
from lliststack import Stack
PROMPT = "Enter an int value (<0 to end): "
myStack = Stack()
value = int(input( PROMPT ))
while value >= 0:
myStack.push( value )
value = int(input( PROMPT ))
while not myStack.isEmpty():
value = myStack.pop()
print( value )
class ExtoPostfix:
"""
Receive an infix expression and turn it into a postfix expression.
This is a helper module of postfixCal.py.
"""
def __init__(self):
self._isp = {
'#': 0,
'(': 1,
'*': 5,
'/': 5,
'+': 3,
'-': 3,
')': 6
} # in stack priority
self._icp = {
'#': 0,
'(': 6,
'*': 4,
'/': 4,
'+': 2,
'-': 2,
')': 1
} # in coming priority
# the list used to save the final postfix expression.
self._postfix = []
# the stack used to change the order of operators.
self._oprtStack = Stack()
def __str__(self):
self._postfix = [
elem for elem in self._postfix if elem != ')' and elem != '('
]
return ','.join(self._postfix)
def _getPostfix(self, expr):
"""
Algorithm:
1)initialize the _oprtStack by pushing '#' into it.
2)read in the first element of the infix expr, and assign it to variable ch.
3)repeat the following steps until ch = '#', meanwhile, the top element of the _oprtStack is also '#':
a)if ch is operand, append it to the _postfix, and read the next ch;
b)if ch is operator, compare the priority(icp) of ch and the priority(isp) of the top element(op) in _oprtStack:
if icp(ch) > isp(op), push ch onto _oprtStack, and read another ch
if icp(ch) < isp(op), pop the top element in _oprtStack, and append it to _postfix
if icp(ch) == isp(op), pop the top element in _oprtStack,if op is '(', read another ch.
"""
expr = expr.split()
self._oprtStack.push('#')
ch = expr.pop(0)
while self._oprtStack.isEmpty() == False and ch != '#':
if ch.isdigit():
self._postfix.append(ch)
ch = expr.pop(0)
else:
ch1 = self._oprtStack.peek()
if self._isp[ch1] < self._icp[ch]:
self._oprtStack.push(ch)
ch = expr.pop(0)
elif self._isp[ch1] > self._icp[ch]:
out = self._oprtStack.pop()
self._postfix.append(out)
else:
out = self._oprtStack.pop()
if out == '(':
ch = expr.pop(0)
for i in range(len(self._oprtStack) - 1):
ch1 = self._oprtStack.pop()
self._postfix.append(ch1)
def backExpr(self, expr):
self._getPostfix(expr)
return self._postfix
from lliststack import Stack
values = Stack()
for i in range(16):
if i % 3 == 0:
values.push(i)
elif i % 4 == 0:
values.pop()
while not values.isEmpty():
print(values.pop())
