其思想可以用於解析數學表示式等，此處以比較簡單的正規表示式為例。
注：如果想要解析數學表示式，**需要做一些改動，主要是操作符優先順序部分。
此處**分為兩塊，第一部分為操作符列舉類，第二部分為處理方法
from enum import enum
'''操作符列舉類
'''class concatenum(enum):
'''連線
'''concat = "concat" # 與
class orenum(enum):
'''組合
'''or = "or" # 或 |
class repeatenum(enum):
'''重複
'''star_repeat = "star_repeat" # 重複至少0次 *
add_repeat = "add_repeat" # 重複至少1次 +
zero_or_one = "zero_or_one" # 重複1次或者0次 ？
left_repeat = "repeat_left" # 重複次中的n
right_repeat = "right_repeat" # 重複次中的m
class unitenum(enum):
'''單元
'''left_unit = "left_unit" # () 中的（
right_unit = "right_unit" # () 中的 )
from enum import enum
from re_nfa_dfa.class_enum import concatenum, repeatenum, unitenum, orenum
def is_placeholder(char):
'''判斷乙個字元是否為佔位符，即是否為 | ? * + ( ) 中的乙個
:param char:
:return:
'''placeholder_list = ['|', '?', '*', '+', '', '(', ')']
if isinstance(char, str):
if char in placeholder_list:
return true
elif isinstance(char, enum):
if char in [concatenum.concat, orenum.or, repeatenum.right_repeat, repeatenum.left_repeat,
repeatenum.zero_or_one, repeatenum.star_repeat, repeatenum.add_repeat, unitenum.left_unit,
unitenum.right_unit]:
return true
return false
def is_one_operator(char):
'''判斷乙個字元是否為一元操作符
:param char:
:return:
'''placeholder_list = ['?', '*', '+']
if isinstance(char, str):
if char in placeholder_list:
return true
elif isinstance(char, enum):
if char in [repeatenum.zero_or_one, repeatenum.star_repeat, repeatenum.add_repeat]:
return true
return false
def load_infix_expression_to_list(infix_expression: str):
'''將輸入的中綴表示式讀成list形式
這裡對輸入的格式進行一次預處理，歸一化入口
:param infix_expression:
:return:
'''placeholder_dict = ': repeatenum.right_repeat, '(': unitenum.left_unit,
')': unitenum.right_unit}
infix_express_list = list(infix_expression)
new_infix_express_list =
last_char = none
for char in infix_express_list:
if char in placeholder_dict:
else:
if last_char and char != ',' and last_char != ',' and (
is_one_operator(last_char) or not is_placeholder(last_char)):
last_char = char
return new_infix_express_list
def get_operator_prioraty(operator):
'''得到操作符的優先順序
:param operator:
:return:
'''if operator in [repeatenum.add_repeat, repeatenum.star_repeat, repeatenum.zero_or_one]:
return 2
elif operator in [concatenum.concat, orenum.or]:
return 1
return -1
def compare_operator(operator_1, operator_2):
'''比較兩個操作符的優先順序
:param operator_1: 棧內的操作符優先順序
:param operator_2: 棧外的操作符優先順序
:return: 如果2比較大，返回true
'''operator_2_prioraty = get_operator_prioraty(operator_2)
operator_1_prioraty = get_operator_prioraty(operator_1)
if operator_2_prioraty > operator_1_prioraty:
return true
return false
def infix_to_postfix(infix_expression: list):
'''將中綴表示式轉化為字尾表示式
利用棧來實現
:param infix_expression:
:return:
'''operator_stack =
postfix_expression =
last_reapeat = none
_repeat =
for char in infix_expression:
if not is_placeholder(char):
if last_reapeat == repeatenum.left_repeat:
else:
else:
if char == unitenum.left_unit:
elif char == unitenum.right_unit:
operator = operator_stack.pop()
while operator != unitenum.left_unit and operator_stack:
operator = operator_stack.pop()
elif char == repeatenum.left_repeat:
last_reapeat = repeatenum.left_repeat
elif char == repeatenum.right_repeat:
operator_repeat = "".join(_repeat)
_repeat =
operator_repeat = ''
last_reapeat = repeatenum.right_repeat
else:
while operator_stack:
if compare_operator(operator_stack[-1], char):
break
else:
operator = operator_stack.pop()
if not operator_stack:
while operator_stack:
return postfix_expression
if __name__ == "__main__":
# express = 'c+d?'
express = "(ab)|c+"
infix_list = load_infix_expression_to_list(express)
postfix_list = infix_to_postfix(infix_list)
print(postfix_list)
中綴表示式轉字尾表示式
using system using system.collections.generic using system.text namespace 中綴表示式轉字尾表示式 class convert public void run top break case case while top 1 st...
中綴表示式轉字尾表示式
將乙個普通的中綴表示式轉換為字尾表示式的一般演算法是 首先需要分配2個棧，乙個作為臨時儲存運算子的棧s1 含乙個結束符號 乙個作為輸入字尾表示式的棧s2 空棧 s1棧可先放入優先順序最低的運算子 注意，中綴式應以此最低優先順序的運算子結束。可指定其他字元，不一定非 不可。從中綴式的左端開始取字元，逐...
中綴表示式轉字尾表示式
演算法 1.設定乙個運算子棧 初始時可以將棧頂運算子置為 2.按順序掃瞄中綴表示式，當輸入為運算元時就將其輸出到字尾表示式中 3.當輸入為運算子時，則比較輸入運算子和棧頂運算子的優先順序。若輸入運算子的優先順序高於棧頂運算子的優先順序，則將輸入運算子入棧 否則，棧頂運算子的優先順序高於或等於輸入運算...