it-swarm.com.de

umwandlung von Infix in Präfix

Ich bereite mich auf eine Prüfung vor, bei der ich die Konvertierung der Infix-Notation in polierte Notation für den folgenden Ausdruck nicht verstehen konnte:

(a–b)/c*(d + e – f / g)

Kann jemand Schritt für Schritt sagen, wie der angegebene Ausdruck in Präfix umgewandelt wird?

15
kar
Algorithm ConvertInfixtoPrefix

Purpose: Convert an infix expression into a prefix expression. Begin 
// Create operand and operator stacks as empty stacks. 
Create OperandStack
Create OperatorStack

// While input expression still remains, read and process the next token.

while( not an empty input expression ) read next token from the input expression

    // Test if token is an operand or operator 
    if ( token is an operand ) 
    // Push operand onto the operand stack. 
        OperandStack.Push (token)
    endif

    // If it is a left parentheses or operator of higher precedence than the last, or the stack is empty,
    else if ( token is '(' or OperatorStack.IsEmpty() or OperatorHierarchy(token) > OperatorHierarchy(OperatorStack.Top()) )
    // Push it to the operator stack
        OperatorStack.Push ( token )
    endif

    else if( token is ')' ) 
    // Continue to pop operator and operand stacks, building 
    // prefix expressions until left parentheses is found. 
    // Each prefix expression is Push back onto the operand 
    // stack as either a left or right operand for the next operator. 
        while( OperatorStack.Top() not equal '(' ) 
            OperatorStack.Pop(operator) 
            OperandStack.Pop(RightOperand) 
            OperandStack.Pop(LeftOperand) 
            operand = operator + LeftOperand + RightOperand 
            OperandStack.Push(operand) 
        endwhile

    // Pop the left parthenses from the operator stack. 
    OperatorStack.Pop(operator)
    endif

    else if( operator hierarchy of token is less than or equal to hierarchy of top of the operator stack )
    // Continue to pop operator and operand stack, building prefix 
    // expressions until the stack is empty or until an operator at 
    // the top of the operator stack has a lower hierarchy than that 
    // of the token. 
        while( !OperatorStack.IsEmpty() and OperatorHierarchy(token) lessThen Or Equal to OperatorHierarchy(OperatorStack.Top()) ) 
            OperatorStack.Pop(operator) 
            OperandStack.Pop(RightOperand) 
            OperandStack.Pop(LeftOperand) 
            operand = operator + LeftOperand + RightOperand 
            OperandStack.Push(operand)
        endwhile 
        // Push the lower precedence operator onto the stack 
        OperatorStack.Push(token)
    endif
endwhile 
// If the stack is not empty, continue to pop operator and operand stacks building 
// prefix expressions until the operator stack is empty. 
while( !OperatorStack.IsEmpty() ) OperatorStack.Pop(operator) 
    OperandStack.Pop(RightOperand) 
    OperandStack.Pop(LeftOperand) 
    operand = operator + LeftOperand + RightOperand

    OperandStack.Push(operand) 
endwhile

// Save the prefix expression at the top of the operand stack followed by popping // the operand stack.

print OperandStack.Top()

OperandStack.Pop()

End
26
rajdip

Wenn es etwas gibt, was Infix und Präfix bedeutet, das Sie nicht ganz verstehen, würde ich Ihnen dringend vorschlagen, lesen Sie diesen Abschnitt Ihres Lehrbuchs erneut. Sie tun sich keinen Gefallen, wenn Sie mit der richtigen Antwort für dieses eine Problem herauskommen, aber das Konzept nicht verstehen.

Algorithmisch ist es ziemlich einfach. Sie benehmen sich einfach selbst wie ein Computer. Beginnen Sie damit, jede Berechnung in der Reihenfolge, in der sie berechnet werden würde, mit Parens zu versehen. Bewegen Sie dann (wieder in der Reihenfolge von der ersten bis zur letzten Berechnung) den Operator vor den Ausdruck auf der linken Seite. Danach können Sie die Entfernung vereinfachen, indem Sie die Parens entfernen.

5
T.E.D.

(a–b)/c*(d + e – f / g)

Präfixnotation (Reverse Polish hat den Operator zuletzt; es ist nicht klar, welche Sie gemeint haben, aber das Prinzip ist genau das gleiche):

  1. (/ f g)
  2. (+ d e)
  3. (- (+ d e) (/ f g))
  4. (- a b)
  5. (/ (- a b) c)
  6. (* (/ (- a b) c) (- (+ d e) (/ f g)))
5
Caleb Hattingh
(a–b)/c*(d + e – f / g)

schritt 1: (a-b)/c*(d+e- /fg))

schritt 2: (a-b)/c*(+de - /fg)

schritt 3: (a-b)/c * -+de/fg

Schritt 4: -ab/c * -+de/fg

schritt 5: /-abc * -+de/fg

schritt 6: */-abc-+de/fg

Dies ist die Präfixnotation.

4

Ich habe diese Methode auf youtube gesehen und hier gepostet. 

gegebener Infix-Ausdruck: (a – b)/c * (d + e - f/g) 

dreh es um : 

) g/f-e + d (* c /) b-a (

zeichen von links nach rechts lesen.
Verwalten Sie einen Stapel für Operatoren

 1. if character is operand add operand to the output
 2. else if character is operator or )
   2.1 while operator on top of the stack has lower or **equal** precedence than this character pop
   2.2 add the popped character to the output.
   Push the character on stack

 3. else if character is parenthesis ( 
    3.1 [ same as 2 till you encounter ) . pop ) as well
 4. // no element left to read
   4.1 pop operators from stack till it is not empty
   4.2 add them to the output. 

reverse the output and print.

credits: youtube

3
Rohit

(a – b)/c * (d + e - f/g)

denken Sie daran, den Ausdruck von links nach rechts zu scannen Beginnen Sie mit Klammern Befolgen Sie die WHAS COMES FIRST-Regel ... *, /,% sind auf derselben Ebene und höher als + und - .... so (ab) = -bc-Präfix (ab) = bc- für Postfix Ein weiterer Klammerbegriff: (d + e - f/g) = Bewegen Sie die/zuerst dann plus '+' zuerst vor dem Minus-Seufzer '-' (denken Sie daran, sie befinden sich auf derselben Ebene ..) (d + e - f/g) move/first ( d + e - (/ fg)) = Präfix (d + e - (fg /)) = postfix gefolgt von + dann - ((+ de) - (/ fg)) = Präfix ((de +) - (fg /)) = postfix

(- (+ de) (/ fg)) = Präfix, so dass der neue Ausdruck jetzt ist - + de/fg (1) ((de +) (fg /) -) = postfix, so dass der neue Ausdruck jetzt de + ist fg/- (2)

(a – b)/c * daher

  1. (a-b)/c * (d + e - f/g) = -bc Präfix [-ab]/c * [- + de/fg] ---> aus (1) /c * Bewegen Sie sich noch nicht so '/' steht an erster Stelle vor '*', da sie sich auf derselben Ebene befinden, bewegen Sie '/' ganz nach rechts:/[- ab] c * [- + de/fg] dann '*' ganz nach rechts schieben

    • / [-ab] c [- + de/fg] = Entferne die Gruppierungssymbole = */- abc- + de/fg -> Präfix
  2. (ab)/c * (d + e - f/g) = bc- für Postfix [ab -]/c * [de + fg/-] ---> aus (2) so '/' kommt vor '', da sie sich auf der gleichen Ebene befinden, bewegen Sie '/' ganz nach links: [ab-] c [de + fg /-(//), dann bewegen Sie' 'nach das äußerste linke [ab-] c [de + fg/-]/ = entfernt die Gruppierungssymbole = ab - cde + fg/-/* -> Postfix 

1
danny albay

Dieser Algorithmus hilft Ihnen zum besseren Verständnis.

Schritt 1. Drücken Sie ")" auf STACK und fügen Sie "(" bis zum Ende von A ein.

Schritt 2. Scannen Sie A von rechts nach links und wiederholen Sie die Schritte 3 bis 6 für jedes Element von A, bis der STACK leer ist.

Schritt 3. Wenn ein Operand angetroffen wird, fügen Sie ihn zu B hinzu.

Schritt 4. Wenn eine rechte Klammer gefunden wird, schieben Sie sie auf STACK.

Schritt 5. Wenn ein Operator angetroffen wird, dann: ein. Staple wiederholt aus STACK und füge jeden Operator (oben auf STACK) zu B hinzu, der dasselbe .__ hat. oder höher als der Operator . b. Operator zu STACK hinzufügen.

Schritt 6. Wenn linke Klammer gefunden wird, dann ein. Kehre immer wieder aus dem STACK und füge zu B hinzu (jeder Operator auf dem Stapel, bis eine linke Klammer gestoßen ist) b. Entfernen Sie die linke Klammer.

Schritt 7. Beenden

0

die einfache Google-Suche ergab: this . Zweifellos kann jeder das einfacher erklären. Aber ich denke, nach einer Bearbeitung kann ich versuchen, die Konzepte vorzustellen, so dass Sie Ihre eigene Frage beantworten können.

Hinweis : 

Studieren Sie für die Prüfung, hart, Sie müssen. Voraussagen Sie, Klasse hoch, ich tue: D

Erklärung:

Es geht darum, wie Operationen Operanden zugeordnet werden. Jeder Notationstyp hat seine eigenen Regeln. Sie müssen nur diese Regeln brechen und sich daran erinnern. Wenn ich Ihnen gesagt habe, ich hätte (2 * 2)/3 als [* /] (2,2,3) geschrieben, müssen Sie nur lernen, wie man die letztere Notation in der ersten Notation dreht. 

In meiner benutzerdefinierten Notation heißt es, dass die ersten beiden Operanden multipliziert und dann der resultierende Operand durch den dritten geteilt wird. Kapiert ? Sie versuchen dir drei Dinge beizubringen.

  1. Mit verschiedenen Notizen vertraut werden. Das Beispiel, das ich gegeben habe, ist das, was Sie in Assembler-Sprachen finden. Operanden (auf die Sie reagieren) und Operationen (was Sie mit den Operanden tun möchten).
  2. Vorrangregeln in der Berechnung müssen nicht unbedingt denen der Mathematik folgen. 
  3. Bewertung: Wie eine Maschine Programme wahrnimmt und wie sie zur Laufzeit angeordnet werden kann.
0
Hassan Syed

Infix an PostFix mit Stack:

     Example: Infix-->         P-Q*R^S/T+U *V
     Postfix -->      PQRS^*T/-UV

     Rules:
    Operand ---> Add it to postfix
    "(" ---> Push it on the stack
    ")" ---> Pop and add to postfix all operators till 1st left parenthesis
   Operator ---> Pop and add to postfix those operators that have preceded 
          greater than or equal to the precedence of scanned operator.
          Push the scanned symbol operator on the stack
0
Eye Sun

In Prefix-Ausdrucksoperatoren stehen zuerst Operanden: + ab [oprator ab]

Infix: (a–b)/c*(d + e – f / g)


Schritt 1: (a - b) = (- ab) ['(' hat höchste Priorität)

schritt 2: (d + e - f / g) = (d + e - / fg) ['/' hat höchste Priorität]

                       = (+ de - / fg )

          ['+','-' has same priority but left to right associativity]

                       = (- + de / fg)

Schritt 3: (-ab )/ c * (- + de / fg) = / - abc * (- + de / fg)

                                 = * / - abc - + de / fg 

Präfix: * / - abc - + de / fg

0
sdpshaw

https://en.wikipedia.org/wiki/Shunting-yard_algorithm

Der Rangierbahnhof-Algorithmus kann auch angewendet werden, um das Präfix __ zu erzeugen. Notation (auch polnische Notation genannt). Dazu müsste man einfach Beginnen Sie am Ende einer Zeichenkette, die analysiert werden soll, und arbeiten Sie Rückwärts, kehren Sie die Ausgabewarteschlange um (und machen Sie die Ausgabewarteschlange .__ zu einem Ausgabestapel), und drehen Sie das Verhalten der linken und rechten Klammer (Erinnern Sie sich daran, dass das Verhalten der jetzt linken Klammer so lange angezeigt werden sollte, bis eine jetzt rechte Klammer findet).

from collections import deque
def convertToPN(expression):
    precedence = {}
    precedence["*"] = precedence["/"] = 3
    precedence["+"] = precedence["-"] = 2
    precedence[")"] = 1

    stack  = []
    result = deque([])
    for token in expression[::-1]:
        if token == ')':
            stack.append(token)
        Elif token == '(':
            while stack:
                t = stack.pop()
                if t == ")": break
                result.appendleft(t)
        Elif token not in precedence:
            result.appendleft(token)
        else:
            # XXX: associativity should be considered here
            # https://en.wikipedia.org/wiki/Operator_associativity
            while stack and precedence[stack[-1]] > precedence[token]:
                result.appendleft(stack.pop())
            stack.append(token)

    while stack:
        result.appendleft(stack.pop())

    return list(result)

expression = "(a - b) / c * (d + e - f / g)".replace(" ", "")
convertToPN(expression)

durchschreiten:

step 1 : token ) ; stack:[ ) ]
result:[  ]
step 2 : token g ; stack:[ ) ]
result:[ g ]
step 3 : token / ; stack:[ ) / ]
result:[ g ]
step 4 : token f ; stack:[ ) / ]
result:[ f g ]
step 5 : token - ; stack:[ ) - ]
result:[ / f g ]
step 6 : token e ; stack:[ ) - ]
result:[ e / f g ]
step 7 : token + ; stack:[ ) - + ]
result:[ e / f g ]
step 8 : token d ; stack:[ ) - + ]
result:[ d e / f g ]
step 9 : token ( ; stack:[  ]
result:[ - + d e / f g ]
step 10 : token * ; stack:[ * ]
result:[ - + d e / f g ]
step 11 : token c ; stack:[ * ]
result:[ c - + d e / f g ]
step 12 : token / ; stack:[ * / ]
result:[ c - + d e / f g ]
step 13 : token ) ; stack:[ * / ) ]
result:[ c - + d e / f g ]
step 14 : token b ; stack:[ * / ) ]
result:[ b c - + d e / f g ]
step 15 : token - ; stack:[ * / ) - ]
result:[ b c - + d e / f g ]
step 16 : token a ; stack:[ * / ) - ]
result:[ a b c - + d e / f g ]
step 17 : token ( ; stack:[ * / ]
result:[ - a b c - + d e / f g ]

# the final while
step 18 : token ( ; stack:[  ]
result:[ * / - a b c - + d e / f g ]
0
Dyno Fu

hier ist eine Java-Implementierung für die Konvertierung von Infix in Präfix und Auswertung des Präfixausdrucks (basierend auf dem Rajdip-Algorithmus).

import Java.util.*;

public class Expression {
    private static int isp(char token){
        switch (token){
            case '*':
            case '/':
                return 2;
            case '+':
            case '-':
                return 1;
            default:
                return -1;
        }
    }
    private static double calculate(double oprnd1,double oprnd2,char oprt){
        switch (oprt){
            case '+':
                return oprnd1+oprnd2;
            case '*':
                return oprnd1*oprnd2;
            case '/':
                return oprnd1/oprnd2;
            case '-':
                return oprnd1-oprnd2;
            default:
                return 0;
        }
    }
    public static String infix2prefix(String infix) {
        Stack<String> OperandStack = new Stack<>();
        Stack<Character> OperatorStack = new Stack<>();
        for(char token:infix.toCharArray()){
            if ('a' <= token && token <= 'z')
                OperandStack.Push(String.valueOf(token));
            else if (token == '(' || OperatorStack.isEmpty() || isp(token) > isp(OperatorStack.peek()))
                OperatorStack.Push(token);
            else if(token == ')'){
                while (OperatorStack.peek() != '(') {
                    Character operator = OperatorStack.pop();
                    String RightOperand = OperandStack.pop();
                    String LeftOperand = OperandStack.pop();
                    String operand = operator + LeftOperand + RightOperand;
                    OperandStack.Push(operand);
                }
                OperatorStack.pop();
            }
            else if(isp(token) <= isp(OperatorStack.peek())){
                while (!OperatorStack.isEmpty() && isp(token)<= isp(OperatorStack.peek())) {
                    Character operator = OperatorStack.pop();
                    String RightOperand = OperandStack.pop();
                    String LeftOperand = OperandStack.pop();
                    String operand = operator + LeftOperand + RightOperand;
                    OperandStack.Push(operand);
                }
                OperatorStack.Push(token);
            }
        }
        while (!OperatorStack.isEmpty()){
            Character operator = OperatorStack.pop();
            String RightOperand = OperandStack.pop();
            String LeftOperand = OperandStack.pop();
            String operand = operator + LeftOperand + RightOperand;
            OperandStack.Push(operand);
        }
        return OperandStack.pop();
    }
    public static double evaluatePrefix(String prefix, Map values){
        Stack<Double> stack = new Stack<>();
        prefix = new StringBuffer(prefix).reverse().toString();
        for (char token:prefix.toCharArray()){
            if ('a'<=token && token <= 'z')
                stack.Push((double) values.get(token));
            else {
                double oprnd1 = stack.pop();
                double oprnd2 = stack.pop();
                stack.Push(calculate(oprnd1,oprnd2,token));
            }
        }
        return stack.pop();
    }
    public static void main(String[] args) {
        Map dictionary = new HashMap<>();
        dictionary.put('a',2.);
        dictionary.put('b',3.);
        dictionary.put('c',2.);
        dictionary.put('d',5.);
        dictionary.put('e',16.);
        dictionary.put('f',4.);
        dictionary.put('g',7.);
        String s = "((a+b)/(c-d)+e)*f-g";
        System.out.println(evaluatePrefix(infix2prefix(s),dictionary));
    }
}