преобразование от инфикса до префикса

Может быть, вы имеете в виду обратную польскую нотацию ? Если да, вы можете найти в Википедии очень подробный пошаговый пример преобразования; если нет, то я понятия не имею, о чем вы спрашиваете: (

Возможно, вы также захотите прочитать мой ответ на другой вопрос, где я предоставил такую ​​реализацию: Простые операции C ++ (+, -, /, *) оценка class

Если вы чего-то не совсем понимаете в том, что означают инфикс и префикс, я настоятельно рекомендую вам перечитать этот раздел вашего учебника . Вы не окажете себе никакой пользы, если вы выйдете из этого с правильным ответом на эту единственную проблему, но все равно не поймете концепции.

С точки зрения алгоритма, это чертовски просто. Вы просто немного ведете себя как компьютер. Начните с того, что заключите скобки вокруг каждого вычисления в том порядке, в котором он будет вычисляться. Затем (снова в порядке от первого вычисления к последнему) просто переместите оператор перед выражением в его левой части. После этого вы можете упростить, удалив скобки.

простой поиск Google дал это . Сомневаюсь, что кто-нибудь может объяснить это проще. Но я думаю, после редактирования, я могу попытаться выдвинуть понятий, чтобы вы могли ответить на свой вопрос.

Подсказка:

Готовиться к экзамену, тяжело, вы должны. Предсказать вам, получить высокую оценку, я делаю: D

Пояснение:

Все дело в способ, которым операции связаны с операндами.Каждый тип записи имеет свои собственные правила. Вам просто нужно сломать и запомнить эти правила. Если бы я сказал вам, что написал (2 * 2) / 3 как [* /] (2,2,3), все, что вам нужно сделать, это научиться превращать последнее обозначение в первое обозначение.

Моя обычная нотация гласит, что если взять первые два операнда и умножить их, то полученный операнд нужно разделить на третий. Возьми ? Они пытаются научить вас трем вещам.

1. Чтобы освоиться с разными обозначениями. Я привел пример того, что вы найдете на языках ассемблера. операнды (с которыми вы действуете) и операции (что вы хотите сделать с операндами).
2. Правила приоритета в вычислениях не обязательно должны следовать правилам, найденным в математике.
3. Оценка: как машина воспринимает программы и как она может упорядочивать их во время выполнения.

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

Префиксная нотация (у обратного поляка оператор последний, непонятно какой, но принцип будет точно таким же):

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

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