def __balanced_parenthesis(self, expression: str) -> bool:
stack = Stack()
error = False
for i in expression:
if i == "(":
stack.push(i)
elif i == ")":
if stack.is_empty():
error = True
break
stack.pop()
if error or not stack.is_empty():
return False
return True
def __reverse_expression(self, expression: str) -> str:
expression = self.__split(expression, " ")
stack = Stack()
for i in expression:
stack.push(i)
expression = ""
while not stack.is_empty():
expression += stack.pop() + " "
return expression[:len(expression) - 1]
def arithmetic_expression_evaluation(self) -> float:
"""
Evaluación de la expresión aritmética en notación Postfix,
utilizando una Stack, calculando el resultado final de la expresión.
"""
result = None
expression_postfix = self.postfix()
if not expression_postfix:
return
postfix_list = self.__split(expression_postfix, " ")
operands_stack = Stack()
for i in postfix_list:
if self.__isdigit(i):
operands_stack.push(i)
elif i in "+-*/^":
num2 = operands_stack.pop()
num1 = operands_stack.pop()
result = self.__operate(num1, num2, i)
operands_stack.push(str(result))
return result
def postfix(self) -> str:
"""
Método que convierte una expresión Infix a una expresión Postfix,
haciendo uso de una Stack. Separar operandos y operadores por un
espacio en blanco.
"""
priorities = {"+": 1, "-": 1, "*": 2, "/": 2, "^": 3, "(": 0}
operators_stack = Stack()
expression_infix = self.infix()
if not expression_infix:
return
infix_list = self.__split(expression_infix, " ")
postfix_list = SinglyLinkedList()
for i in infix_list:
if self.__isdigit(i):
postfix_list.append(i)
elif i == ")":
top = operators_stack.pop()
while top != "(" and not operators_stack.is_empty():
postfix_list.append(top)
top = operators_stack.pop()
elif i == "(":
operators_stack.push(i)
elif i in priorities:
if operators_stack.is_empty():
operators_stack.push(i)
else:
top = operators_stack.peek()
if priorities[i] > priorities[top] or i == top == "^":
operators_stack.push(i)
else:
while not operators_stack.is_empty():
top = operators_stack.peek()
if priorities[top] >= priorities[i]:
postfix_list.append(operators_stack.pop())
else:
break
operators_stack.push(i)
while not operators_stack.is_empty():
postfix_list.append(operators_stack.pop())
expression_postfix = ""
for i in postfix_list:
expression_postfix += str(i) + " "
return expression_postfix[:len(expression_postfix) - 1]