需要一种算法将命题逻辑表达式从中缀转换为后缀

Question

I need an algorithm to convert propositional logic expressions from infix to postfix so that I can then convert them into expression trees. Here are some examples of propositional logic expressions I am working with.

T

((r^(~pvp))→(~pvp))

(Tv~((p^(~qvq))))

Converting infix to postfix for arithmetic expressions is a very standard data structures textbook problem. However, I haven't been able to find many resources on this type of conversion for propositional logic.

I have tried using the algorithm provided in the following link

https://www.geeksforgeeks.org/stack-set-2-infix-to-postfix/

The algorithm doesn't seem to work when I apply it to propositional logic expressions. My code keeps popping an empty stack. I think this might have to do with the fact that operations in propositional logic (unlike in arithmetic) don't have a precedence, so I am not sure how to handle this. Also, I don't know if handling the NOT operator (~) should be a special case, as it is a unary operator where all the other operators are binary.

If someone could please recommend or describe an algorithm for converting infix propositional logic expressions into postfix, I would really appreciate it! Thanks so much.

Answer 1

You just need to implement the correct parsing of the unary operator.

Given that you don't rely on precedence, but will always enclose binary infix operations in parentheses, the process can be simplified, as there is then no need for an explicit stack with operators; the call stack will take care of their order.

Here is how it could be coded:

def inToPostFix(s):
    def reject(what): # Produce a readable error
        raise SyntaxError("Expected {}, but got {} at index {}".format(
            what or "EOF", 
            "'{}'".format(tokens[-1]) if tokens else "EOF", 
            len(s) - len(tokens)
        ))

    get = lambda: tokens.pop() if tokens else ""
    put = lambda token: output.append(token)
    match = lambda what: tokens[-1] in what if tokens else what == ""
    expect = lambda what: get() if match(what) else reject(what)

    def suffix():
        token = get()
        term()
        put(token)

    def parens(): 
        expect("(")
        expression(")")

    def term():
        if match(identifier): put(get())
        elif match(unary): suffix()
        elif match("("): parens()
        else: expect("an identifier, a unary operator or an opening parenthesis");

    def expression(terminator):
        term()
        if match(binary): suffix()
        expect(terminator)

    # Define the token groups
    identifier = "abcdefghijklmnopqrstuwxyz"
    identifier += identifier.upper()
    unary = "~";
    binary = "^v→";
    tokens = list(reversed(s)) # More efficient to pop from the end
    output = [] # Will be populated during the parsing
    expression("") # Parse!
    return "".join(output)

Example call:

print(inToPostFix("(Tv~((p^(~qvq))))"))

Note that here parentheses may be omitted when they would wrap the whole expression.