def divideBy2(decNumber):
remstack = Stack()
while decNumber > 0:
rem = decNumber % 2
remstack.push(rem)
decNumber = decNumber // 2
binString = ""
while not remstack.isEmpty():
binString = binString + str(remstack.pop())
return binString
def baseConverter(decNumber, base):
digits = "0123456789ABCDEF"
remstack = Stack()
while decNumber > 0:
rem = decNumber % base
remstack.push(rem)
decNumber = decNumber // base
newString = ""
while not remstack.isEmpty():
newString = newString + digits[remstack.pop()]
return newString
def toStr(n, base):
convertString = '0123456789ABCDEF' # can cover base upto 16
rStack = Stack()
while n >0:
if n<base:
rStack.push(convertString[n])
else:
rStack.push(convertString[n % base])
n= n // base
res = ''
while not rStack.isEmpty():
res = res + rStack.pop()
return res
def postfixEval(postfixExpr):
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)
return operandStack.pop()
def parChecker(symbolString):
s = Stack()
balanced = True
index = 0
while index < len(symbolString) and balanced:
symbol = symbolString[index]
if symbol == "(":
s.push(symbol)
else:
if s.isEmpty():
balanced = False
else:
s.pop()
index = index + 1
if balanced and s.isEmpty():
return True
else:
return False
def parChecker(symbolString):
s = Stack()
balanced = True
index = 0
while index < len(symbolString) and balanced:
symbol = symbolString[index]
if symbol in "([{":
s.push(symbol)
else:
if s.isEmpty():
balanced = False
else:
top = s.pop()
if not matches(top,symbol):
balanced = False
index = index + 1
if balanced and s.isEmpty():
return True
else:
return False
def revstring(mystr):
s = Stack()
for each in mystr:
s.push(each)
result = ''.join(s.pop() for i in range(s.size()))
print(result)
def size(self):
return len(self.items)
'''
Remember that nothing happens when we click the run button other than
the definition of the class. We must create a Stack object and then use
it. ActiveCode 2 shows the Stack class in action as we perform the
sequence of operations from Table 1. Notice that the definition of the
Stack class is imported from the pythonds module.
'''
# Make sure to pip install pythonds. I was able to use that import
# statement in the Python prompt without any issues:
from pythonds.basic import Stack
s=Stack()
print(s.isEmpty())
s.push(4)
s.push('dog')
print(s.peek())
s.push(True)
print(s.size())
print(s.isEmpty())
s.push(8.4)
print(s.pop())
print(s.pop())
print(s.size())
'''
from pythonds.basic import Stack
s = Stack()
print(s.isEmpty())
s.push(4)
s.push('dog')
print(s.peek()) # dog
print(s.pop()) # dog
print(s.size(), s.items)
print('dfsdf %s' % 'xxx')
def creatS(self, fpexp):
fplist = fpexp.split()
p_stack = Stack()
e_tree = BinaryTree('')
p_stack.push(e_tree)
current_tree = e_tree
for i in fplist:
if i == "(":
current_tree.insert_left('')
p_stack.push(current_tree)
current_tree = current_tree.get_left_child()
elif i in "'and','or'":
current_tree.set_root_val(i)
current_tree.insert_right('')
p_stack.push(current_tree)
current_tree = current_tree.get_right_child()
elif i in "'not'":
current_tree = p_stack.pop()
current_tree.set_root_val(i)
current_tree.insert_left(False)
current_tree.insert_right('')
p_stack.push(current_tree)
current_tree = current_tree.get_right_child()
elif i == ')':
current_tree = p_stack.pop()
else:
current_tree.set_root_val(i)
parent = p_stack.pop()
current_tree = parent
if i not in self.symbols:
self.symbols.append(i)
self.val = e_tree
def infixToPostfix(tokenList):
"""Converts an infix arithmetic expression to postfix"""
# Creating a dictionary to hold oprator precedence
prec = {}
prec['*'] = 3
prec['/'] = 3
prec['+'] = 2
prec['-'] = 2
prec['('] = 1
opStack = Stack()
postfixList = []
for token in tokenList:
# Adding any operands to the postFix list
if token in string.ascii_uppercase:
postfixList.append(token)
elif token == '(':
opStack.push(token)
elif token == ')':
topToken = opStack.pop()
while topToken != '(':
postfixList.append(topToken)
topToken = opStack.pop()
else:
while (not opStack.isEmpty()
and (prec[opStack.peek()] >= prec[token])):
postfixList.append(opStack.pop())
opStack.push(token)
while not opStack.isEmpty():
postfixList.append(opStack.pop())
return " ".join(postfixList)
def infixToPostfix(infixexpr):
prec = {"*": 3, "/": 3, "+": 2, "-": 2, "(": 1}
opStack = Stack()
postfixList = []
try:
tokenList = infixexpr.split()
for token in tokenList:
if token in "ABCDEFGHIJKLMNOPQRSTUVWXYZ" or token in "0123456789":
postfixList.append(token)
elif token == '(':
opStack.push(token)
elif token == ')':
topToken = opStack.pop()
while topToken != '(':
postfixList.append(topToken)
topToken = opStack.pop()
else:
while (not opStack.isEmpty()) and \
(prec[opStack.peek()] >= prec[token]):
postfixList.append(opStack.pop())
opStack.push(token)
except:
return f"Incorrect object type for infix expression.{TypeError}"
while not opStack.isEmpty():
postfixList.append(opStack.pop())
return " ".join(postfixList)
def infix2postfix(infix):
prec = {"*": 3, "/": 3, "+": 2, "-": 2, "(": 1}
opStack = Stack()
postfixLst = []
token_lst = infix.split()
for token in token_lst:
if token in string.ascii_uppercase:
postfixLst.append(token)
elif token == '(':
opStack.push(token)
elif token == ')':
topToken = opStack.pop()
while topToken != "(":
postfixLst.append(topToken)
topToken = opStack.pop()
else:
while (not opStack.isEmpty()) and (prec[opStack.peek()] >=
prec[token]): # peek可看顶端元素
postfixLst.append(opStack.pop())
opStack.push(token)
while not opStack.isEmpty():
postfixLst.append(opStack.pop())
return " ".join(postfixLst)
def infix_to_postfix(infix_expr):
"""
Convert an infix mathematical expression into an postfix expression.
:param infix_expr: String of infix expression
:return: original infix expression as a postfix expression
"""
prec = {"**": 4, "//": 3, "*": 3, "/": 3, "+": 2, "-": 2, "(": 1}
op_stack = Stack() # Stack to hold operators
postfix_list = [] # Where we will insert our postfix expression to print
token_list = []
tmp_str = ''
operator_str = ''
for ch in infix_expr: # Convert expression into a list 3.0*5 + 4
if ch in "ABCDEFGHIJKLMNOPQRSTUVWXYZ" or ch in "0123456789.":
if operator_str != '':
token_list.append(operator_str)
operator_str = ''
tmp_str = tmp_str + ch
elif ch in "*+/-":
if tmp_str != '':
token_list.append(tmp_str)
tmp_str = ''
operator_str = operator_str + ch
elif ch in "()":
if tmp_str != '':
token_list.append(tmp_str)
tmp_str = ''
elif operator_str != '':
token_list.append(operator_str)
operator_str = ''
token_list.append(ch)
if tmp_str != '':
token_list.append(tmp_str)
if tmp_str != '':
token_list.append(operator_str)
for token in token_list: # Go through each item in the list.
if token not in "+-**//()":
postfix_list.append(token) # add expression to list, not operator
elif token == '(': # Notify that we'll have an operator of top priority coming up
op_stack.push(token)
elif token == ')':
top_token = op_stack.pop()
while top_token != '(': # Take the operator out of the stack and insert into our pfix list
postfix_list.append(
top_token) # continue for as many tokens were in the ()
top_token = op_stack.pop()
elif token == '':
pass
else:
while (not op_stack.isEmpty()) and \
(prec[op_stack.peek()] >= prec[token]): # compare operator precedence, decide which goes first
postfix_list.append(op_stack.pop())
op_stack.push(token)
while not op_stack.isEmpty():
postfix_list.append(op_stack.pop())
return " ".join(postfix_list)
# 5_convert_integer_string_stack.py
from pythonds.basic import Stack
rStack = Stack()
def toStr(n, base):
convertString = "0123456789ABCDEF"
while n > 0:
if n < base:
rStack.push(convertString[n])
else:
rStack.push(convertString[n % base])
n = n // base
res = ""
while not rStack.isEmpty():
res = res + str(rStack.pop())
return res
print(toStr(1453, 16))
def buildParseTree(expr):
lot = expr.split()
tree = BinaryTree("")
posStack = Stack()
posStack.push(tree)
currentTree = tree
for token in lot:
if token == "(":
currentTree.insertLeft("")
posStack.push(currentTree)
currentTree = currentTree.getLeftChild()
elif token == ")":
currentTree = posStack.pop()
elif token in ["and", "or"]:
currentTree.setRootVal(token)
currentTree.insertRight("")
posStack.push(currentTree)
currentTree = currentTree.getRightChild()
elif token == "not":
parent = posStack.pop()
currentTree = parent
currentTree.setRootVal(token)
posStack.push(currentTree)
currentTree = currentTree.getLeftChild()
elif token in ["1", "0"]:
currentTree.setRootVal(int(token))
parent = posStack.pop()
currentTree = parent
return tree
def infixToPostfixEval(expr):
prec = {}
prec["*"] = 3
prec["/"] = 3
prec["+"] = 2
prec["-"] = 2
prec["("] = 1
opStack = Stack()
operandStack = Stack()
postfixList = []
tokenList = expr.split()
for token in tokenList:
if token in "ABCDEFGHIJKLMNOPQRSTUVWXYZ" or token in "0123456789!":
postfixList.append(token)
elif token == '(':
opStack.push(token)
elif token == ')':
topToken = opStack.pop()
while topToken != '(':
postfixList.append(topToken)
topToken = opStack.pop()
else:
while (not opStack.isEmpty()) and (prec[opStack.peek()] >=
prec[token]):
postfixList.append(opStack.pop())
opStack.push(token)
while not opStack.isEmpty():
postfixList.append(opStack.pop())
str = " ".join(postfixList)
tokenList2 = str.split()
for token in tokenList2:
if token in "ABCDEFGHIJKLMNOPQRSTUVWXYZ":
return "Cannot be evaluated"
elif token in "0123456789":
operandStack.push(int(token))
elif token == '!':
operand = operandStack.pop()
result = math.factorial(operand)
operandStack.push(result)
else:
operand2 = operandStack.pop()
operand1 = operandStack.pop()
result = doMath(token, operand1, operand2)
operandStack.push(result)
x = str, "Evaluates to: ", operandStack.pop()
return x
class ASM_COMPLEX_IF():
args_list = []
reserved_bool1 = 0
reserved_bool2 = 0
stack_args = ''
list_completed = []
formed_code = ''
target_if_true = ''
target_if_false = ''
def __init__(self, args_list, target_if_true, target_if_false):
self.args_list = args_list
self.target_if_true = target_if_true
self.target_if_false = target_if_false
# init a empty stack
self.stack_args = Stack()
# insert each value in the args list into the stack
for item in self.args_list[::-1]:
self.stack_args.push(item)
def detect_conditions(self, cmp):
return conditions[cmp]
def detect_contrary(self, cmp):
return contrary_conditions[cmp]
def detect_bool_available(self):
if self.reserved_bool1 == 0:
self.reserved_bool1 = 1
return 'r_bool_1'
if self.reserved_bool2 == 0:
self.reserved_bool2 = 1
return 'r_bool_1'
def get_params(self):
# peek the value in the stack
temp_op1 = ''
temp_op2 = ''
while self.stack_args.size() > 0:
# peek the value found in stack
curr_val = self.stack_args.peek()
if curr_val not in operands:
if temp_op1 == '':
temp_op1 = self.stack_args.pop()
if temp_op2 == '':
temp_op2 = self.stack_args.pop()
else:
# FOUND A OPERAND
op = self.stack_args.pop()
# generate the if code based on the operand
if op in rel_eq_op:
# get the type of comparison and contrary
cond = self.detect_conditions(op)
contr = self.detect_contrary(cond)
temp = self.detect_bool_available()
# generate the template
template = Template(if_complex['if_false'])
# if reserved bool
# replace the values in template
template = template.safe_substitute(reg1 = temp_op1, reg2 = temp_op2, comp = cond, temp = temp, contr = contr, t_false = self.target_if_false)
# append to the completed code
self.formed_code = self.formed_code + template
# IF IN CASE NOT IN THE BASIC OPERANDS IT IS && OR ||
else:
# DOESNT DO ANYTHING UP TO NOW
op = 0
# test area
# a = ASM_COMPLEX_IF(['r2', 'r1', '>', 'r1', 'r2', '==', '&&', 'sucasa', 'ddfa', '>', '||'])
# a.get_params()
def tranfortExpress(expression):
priority = {}
priority["/"] = 3
priority["*"] = 3
priority["+"] = 2
priority["-"] = 2
priority["("] = 1
emptyStack = Stack()
emptyList = []
tokenList = expression.split()
for token in tokenList:
if token in string.ascii_uppercase:
emptyList.append(token)
elif token == '(':
emptyStack.push(token)
elif token == ')':
topToken = emptyStack.pop()
while topToken != '(':
emptyList.append(topToken)
topToken = emptyStack.pop()
else:
while (not emptyStack.isEmpty()) and \
(priority[emptyStack.peek()] >= priority[token]):
emptyList.append(emptyStack.pop())
emptyStack.push(token)
while not emptyStack.isEmpty():
emptyList.append(emptyStack.pop())
return ' '.join(emptyList)
def base_conversion(base, number):
s = Stack()
while number > 0:
s.push(number % base)
number = number // base
return s
def infixToPostfit(infixexpr):
# 记录操作符优先级
prec = {}
prec["*"] = 3
prec["/"] = 3
prec["+"] = 2
prec["-"] = 2
prec["("] = 1
opStack = Stack()
postfixList = []
# 解析表达式到单词列表
tokenList = infixexpr.split()
#print(tokenList)
for token in tokenList:
if token in "+-*/":
while (not opStack.isEmpty()) and \
(prec[opStack.peek()] >= prec[token]):
postfixList.append(opStack.pop())
opStack.push(token)
elif token == '(':
opStack.push(token)
elif token == ')':
topToken = opStack.pop()
while topToken != '(':
postfixList.append(topToken)
topToken = opStack.pop()
else:
postfixList.append(token)
while not opStack.isEmpty():
postfixList.append(opStack.pop()) # 操作符
return " ".join(postfixList) # 合成后缀表达式
def infixToPostfix(infixexpr):
prec = {}
prec["**"] = 4
prec["*"] = 3
prec["/"] = 3
prec["+"] = 2
prec["-"] = 2
prec["("] = 1
opStack = Stack()
postfixList = []
tokenList = infixexpr.split()
for token in tokenList:
if token in "ABCDEFGHIJKLMNOPQRSTUVWXYZ" or token in "0123456789":
postfixList.append(token)
elif token == '(':
opStack.push(token)
elif token == ')':
topToken = opStack.pop()
while topToken != '(':
postfixList.append(topToken)
topToken = opStack.pop()
else:
while (not opStack.isEmpty()) and \
(prec[opStack.peek()] >= prec[token]):
postfixList.append(opStack.pop())
opStack.push(token)
while not opStack.isEmpty():
postfixList.append(opStack.pop())
return " ".join(postfixList)
def infixToPostfix(infix):
#infix = '(' + infix + ')'
#Initialize Stack.
opStack = Stack()
output = ""
#print(infix)
#Loop Through All Tokens:
for token in infix:
#Case 1: Operator.
if (isOperator(token)):
while (not (opStack.isEmpty()) and isOperator(opStack.peek()) and (
(getAssociativity(token) == 'L'
and getPrecedence(opStack.peek()) >= getPrecedence(token)) or
(getAssociativity(token) == 'R'
and getPrecedence(opStack.peek()) > getPrecedence(token)))):
output += opStack.peek()
opStack.pop()
opStack.push(token)
#Case 2: Left Paranthesis.
elif (token == '('):
opStack.push(token)
#Case 3: Right Paranthesis.
elif (token == ')'):
while (not (opStack.isEmpty()) and opStack.peek() != '('):
output += opStack.peek()
opStack.pop()
#Error-Checking:
if (opStack.isEmpty()):
# print("Empty Stack.")
print(output)
# return "ERROR"
if (opStack.peek() == '('):
opStack.pop()
else:
#Check For Non-Alpha Characters:
if (not (token.isalpha())):
# print("Not Alpha Not Space:", token, ".")
return "ERROR"
output += token
#Append All Remaining Characters From opStack.
while (not (opStack.isEmpty())):
if (opStack.peek() == '(' or opStack.peek() == ')'):
# print("Uh-OH! Mismatched Paranthesis")
return "ERROR"
output += opStack.peek()
opStack.pop()
#Return Output.
return output
- The base of the stack is significant since items stored in the stack that are closer to the base represent those that have beeen in the stack the longest. - LIFO: Last-in first-out - The most recently added item is the one that is in position to be removed first. - This principle provides an ordering based on length of time in the collection. - Newer items are near the top, while older items are near the base. Strength of Stacks: - GREAT for reversing the order of items. - Keeping track of state or when things have occured. ''' # 4.4 ----------------- THE STACK ABSTRACT DATA TYPE ''' Stack() : Creates a new stack that is empty. It needs no parameters and returns an empty stack. push(item) : Adds a new item to the top of the stack. It needs the item and returns nothing. pop() : Removes the top item from the stack. It needs no parameters and returns the item. The stack is modified. peek() : Returns the top item from the stack but does not remove it. It needs no parameters. The stack is not modified. isEmpty() : Tests to see whether the stack is empty. It needs no parameters and returns a boolean value. size() : Returns the number of items on the stack. It needs no parameters and returns an integer. ''' # 4.5 ----------------- IMPLEMENTATING A STACK IN PYTHON
def infixToPostfix(expression):
prec = {}
prec["*"] = 3
prec["/"] = 3
prec["+"] = 2
prec["-"] = 2
prec["("] = 1
tempStack = Stack()
postfixList = []
tokenList = expression.split()
for token in tokenList:
if token in "ABCDEFGHIJKLMNOPQRSTUVWXYZ" or token in "0123456789":
postfixList.append(token)
elif token == "(":
tempStack.push(token)
elif token == ")":
toptoken = tempStack.pop()
while toptoken != '(':
postfixList.append(toptoken)
toptoken = tempStack.pop()
else:
while (not tempStack.isEmpty()) and (prec[tempStack.peek()] >= prec[token]):
postfixList.append(tempStack.pop())
tempStack.push(token)
while not tempStack.isEmpty():
postfixList.append(tempStack.pop())
return " ".join(postfixList)
def convertToTree(postfix):
#If Output convertInfixToPrefix Returned "ERROR" + Postfix = "RORRE".
if (postfix == "RORRE"):
return
#Initialize Stack.
convertToTree = Stack()
for k in range(0, len(postfix)):
#Case 1: Operator + Not-Negation
if (isOperator(postfix[k]) and postfix[k] != "~"):
#Pop Previous One TreeNode.
prevOne = None
if (not (convertToTree.isEmpty())):
prevOne = convertToTree.peek()
convertToTree.pop()
#Pop Previous Two TreeNode.
prevTwo = None
if (not (convertToTree.isEmpty())):
prevTwo = convertToTree.peek()
convertToTree.pop()
#Create + Set New TreeNode.
currentNode = TreeNode(postfix[k])
currentNode.left = prevTwo
currentNode.right = prevOne
convertToTree.push(currentNode)
#Case 2: Operator + Negation.
elif (isOperator(postfix[k]) and postfix[k] == "~"):
#Pop Previous One TreeNode.
prevOne = None
if (not (convertToTree.isEmpty())):
prevOne = convertToTree.peek()
convertToTree.pop()
#Create + Set New TreeNode.
currentNode = TreeNode(postfix[k])
currentNode.left = prevOne
convertToTree.push(currentNode)
#Case 3: New Leaf Node.
else:
currentNode = TreeNode(postfix[k])
convertToTree.push(currentNode)
#Assert Only Root:
# if(convertToTree.size() != 1):
# print("Error In Construction. Must Review Input/Output.")
#Set New Head Value = Top/Root of Stack.
return convertToTree.peek()
def infixToPostfix(infixexpr):
prec = {}
prec["*"] = 3
prec["/"] = 3
prec["+"] = 2
prec["-"] = 2
prec["("] = 1
opStack = Stack()
postfixList = []
tokenList = infixexpr.split()
for token in tokenList:
if token in "ABCDEFGHIJKLMNOPQRSTUVWXYZ" or token in "0123456789":
postfixList.append(token)
elif token == '(':
opStack.push(token)
elif token == ')':
topToken = opStack.pop()
found = False
while topToken != '(' and not opStack.isEmpty():
found = True
postfixList.append(topToken)
topToken = opStack.pop()
if not found:
raise Exception('Unbalanced parentheses,too much ")"')
else:
while (not opStack.isEmpty()) and \
(prec[opStack.peek()] >= prec[token]):
postfixList.append(opStack.pop())
opStack.push(token)
unbalanced_found = False
while not opStack.isEmpty():
last = opStack.pop()
if last == '(':
unbalanced_found = True
raise Exception('Unbalanced parentheses,too much "("')
postfixList.append(last)
return " ".join(postfixList)
def direct_infix_evaluator(infixexpr: str) -> int or float:
prec = {}
prec["*"] = 3
prec["/"] = 3
prec["+"] = 2
prec["-"] = 2
prec["("] = 1
opStack = Stack()
postfixEvaluation = Stack()
tokenList = infixexpr.split()
for token in tokenList:
if token in "ABCDEFGHIJKLMNOPQRSTUVWXYZ" or token in "0123456789":
postfixEvaluation.push(token)
elif token == '(':
opStack.push(token)
elif token == ')':
topToken = opStack.pop()
found = False
while topToken != '(' and not opStack.isEmpty():
found = True
operator = topToken
operand2 = postfixEvaluation.pop()
operand1 = postfixEvaluation.pop()
postfixEvaluation.push(doMath(operator, operand1, operand2))
topToken = opStack.pop()
if not found:
raise Exception('Unbalanced parentheses,too much ")"')
else:
while (not opStack.isEmpty()) and \
(prec[opStack.peek()] >= prec[token]):
operator = opStack.pop()
operand2 = postfixEvaluation.pop()
operand1 = postfixEvaluation.pop()
postfixEvaluation.push(doMath(operator, operand1, operand2))
opStack.push(token)
unbalanced_found = False
while not opStack.isEmpty():
last = opStack.pop()
if last == '(':
unbalanced_found = True
raise Exception('Unbalanced parentheses,too much "("')
operator = last
operand2 = postfixEvaluation.pop()
operand1 = postfixEvaluation.pop()
postfixEvaluation.push(doMath(operator, operand1, operand2))
return postfixEvaluation.pop()
from pythonds.basic import Stack
s = Stack()
def tostr(num, base):
strconv = "0123456789ABCDEF"
while num > 0:
if num < base:
s.push(strconv[num])
else:
s.push(strconv[num % base])
num = num // base
out = ""
while not s.isEmpty():
out = out + str(s.pop())
return out
print(tostr(999999, 2))
from pythonds.basic import Stack s = Stack() s.push(4) print(s.peek())
def infixToPostfix(infixQuery,term):
queryList = infixQuery.split()
queryStack = Stack()
postfixQuery = []
precOperator = {}
precOperator["not"] = 4
precOperator["and"] = 3
precOperator["or"] = 2
precOperator["("] = 1
for query in queryList:
if query in term:
postfixQuery.append(query)
indexNext = queryList.index(query)+1
if indexNext != len(queryList) and (queryList[indexNext] in term):
queryStack.push("and")
elif query == '(':
queryStack.push(query)
elif query == ')':
stackTeratas = queryStack.pop()
while stackTeratas != '(':
postfixQuery.append(stackTeratas)
stackTeratas = queryStack.pop()
else:
while (queryStack.isEmpty() != True) and (precOperator[queryStack.peek()] >= precOperator[query]):
postfixQuery.append(queryStack.pop())
queryStack.push(query)
while (queryStack.isEmpty() != True):
postfixQuery.append(queryStack.pop())
return postfixQuery
def infixToPrefix(infixexpr):
exprList = infixexpr.split(' ')
exprList.reverse()
output = []
opStack = Stack()
for token in exprList:
if token == ')':
opStack.push(token)
elif token == '(': # pop until find the left-parenthesis.
while True:
op = opStack.pop()
if op == ')':
break
else:
output.append(op)
elif token in ['+', '-', '*', '/']:
# pop superior or equal operators then push operator.
# do not pop `)` here.
while not opStack.isEmpty() and opStack.peek() != ')':
if isSuperiorOrEqual(opStack.peek(), token):
output.append(opStack.pop())
else:
break
opStack.push(token)
else:
output.append(token)
# retrieve the remain marks in operation stack.
while not opStack.isEmpty():
output.append(opStack.pop())
output.reverse(
) # output is a reverse of prefix as a result of beginning reverse operation.
return ' '.join(output)
def infixEval(infixexpr):
prec = {}
prec["^"] = 4
prec["*"] = 3
prec["/"] = 3
prec["+"] = 2
prec["-"] = 2
prec["("] = 1
opStack = Stack()
postfixList = []
infixexpr = list(infixexpr)
tokenList = []
for token in infixexpr:
if token != ' ':
tokenList.append(token)
tokenList.append(' ')
else:
continue
tokenList = ''.join(tokenList).split()
for token in tokenList:
if token in "ABCDEFGHIJKLMNOPQRSTUVWXYZ" or token in "0123456789":
postfixList.append(token)
elif token == '(':
opStack.push(token)
elif token == ')':
topToken = opStack.pop()
while topToken != '(':
postfixList.append(topToken)
topToken = opStack.pop()
else:
while (not opStack.isEmpty()) and \
(prec[opStack.peek()] >= prec[token]):
postfixList.append(opStack.pop())
opStack.push(token)
while not opStack.isEmpty():
postfixList.append(opStack.pop())
postfixExpr = " ".join(postfixList)
solution = postfixEval(postfixExpr)
return postfixExpr
def evalPostfix(postfixExpr):
exprList = postfixExpr.split(' ')
operandStack = Stack()
for token in exprList:
if token == '+':
operandStack.push(operandStack.pop() + operandStack.pop())
elif token == '-': # in minus, calculation order is opposite to pop order.
operand1 = operandStack.pop()
operand2 = operandStack.pop()
operandStack.push(operand2 - operand1)
elif token == '*':
operandStack.push(operandStack.pop() * operandStack.pop())
elif token == '/': # in division, calculation order is opposite to pop order.
operand1 = operandStack.pop()
operand2 = operandStack.pop()
operandStack.push(operand2 / operand1)
else:
operandStack.push(float(token))
return operandStack.pop()
def infixToPostfixEval(infixExpre):
prec = {}
prec["!"] = 4
prec["*"] = 3
prec["/"] = 3
prec["+"] = 2
prec["-"] = 2
prec["("] = 1
opStack = Stack()
postfixList = []
tokenList = infixExpre.split()
#infix to postfix
for token in tokenList:
if token in "ABCDEFGHIJKLMNOPQRSTUVWXYZ" or token in "0123456789":
postfixList.append(token)
elif token == '(':
opStack.push(token)
elif token == ')':
topToken = opStack.pop()
while topToken != '(':
postfixList.append(topToken)
topToken = opStack.pop()
else:
while (not opStack.isEmpty()) and \
(prec[opStack.peek()] >= prec[token]):
postfixList.append(opStack.pop())
opStack.push(token)
while not opStack.isEmpty():
postfixList.append(opStack.pop())
postfixExpre = (" ".join(postfixList))
#postfix to eval
operandStack = Stack()
tokenList = postfixExpre.split()
for token in tokenList:
if token in "0123456789":
operandStack.push(int(token))
#seperate statements for factorial
elif token == "!":
operand1 = operandStack.pop()
result = doFactorial(operand1)
operandStack.push(result)
else:
operand2 = operandStack.pop()
operand1 = operandStack.pop()
result = doMath(token, operand1, operand2)
operandStack.push(result)
return postfixExpre, operandStack.pop()
def infixToPostfix(infixexpr):
prec = {}
prec["*"] = 3
prec["/"] = 3
prec["+"] = 2
prec["-"] = 2
prec["("] = 1
opStack = Stack()
postfixList = []
tokenList = infixexpr.split()
for token in tokenList:
if token in string.ascii_uppercase:
postfixList.append(token)
elif token == '(':
opStack.push(token)
elif token == ')':
topToken = opStack.pop()
while topToken != '(':
postfixList.append(topToken)
topToken = opStack.pop()
else:
while (not opStack.isEmpty()) and \
(prec[opStack.peek()] >= prec[token]):
postfixList.append(opStack.pop())
opStack.push(token)
while not opStack.isEmpty():
postfixList.append(opStack.pop())
return " ".join(postfixList)
