Kirjoita ohjelma, joka muuntaa Infix-lausekkeen Postfix-lomakkeeksi.

Infix-lauseke: Muodon a operaattori b (a + b) lauseke eli kun operaattori on jokaisen operandiparin välissä.
Postfix ilmaus: Muodon a b lauseke operaattori (ab+) eli Kun jokaista operandiparia seuraa operaattori.

Esimerkkejä:

Syöte: A + B * C + D
Lähtö: ABC*+D+

Syöte: ((A + B) – C * (D / E)) + F
Lähtö: AB+CDE/*-F+

Miksi ilmaisun postfix-esitys?

Kääntäjä skannaa lausekkeen joko vasemmalta oikealle tai oikealta vasemmalle.
Harkitse ilmaisua: a + b * c + d

• Kääntäjä skannaa ensin lausekkeen arvioidakseen lausekkeen b * c, sitten skannaa uudelleen lausekkeen lisätäkseen siihen a:n.
• Tulos lisätään sitten kohtaan d toisen skannauksen jälkeen.

Toistuva skannaus tekee siitä erittäin tehottoman. Infix-lausekkeet ovat ihmisten helposti luettavissa ja ratkaistavissa, kun taas tietokone ei pysty erottamaan operaattoreita ja sulkuja helposti, joten on parempi muuntaa lauseke postfix-muotoon ennen arviointia.

Vastaava lauseke postfix-muodossa on abc*+d+ . Postfix-lausekkeet voidaan arvioida helposti pinon avulla.

Kuinka muuntaa Infix-lauseke Postfix-lausekkeeksi?

Jos haluat muuntaa infix-lausekkeen postfix-lausekkeeksi, käytä Alla on vaiheet yllä olevan idean toteuttamiseksi:

1. Skannaa infix-lauseke vasemmalta oikealle .

2. Alla on vaiheet yllä olevan idean toteuttamiseksi:
   1. Jos skannattu merkki on operandi, laita se postfix-lausekkeeseen.
   3. Alla on vaiheet yllä olevan idean toteuttamiseksi:
      1. Muussa tapauksessa toimi seuraavasti
         • Jos skannatun operaattorin ensisijaisuus ja assosiatiivisuus ovat suurempia kuin pinon operaattorin etusija ja assosiatiivisuus [tai pino on tyhjä tai pinossa on ' ( ], työnnä se sitten pinoon. [' ^ 'operaattori on oikea assosiatiivinen ja muut operaattorit kuten' + ',' – ',' * 'ja' / ' ovat vasen assosiatiivisia].
           • Tarkista erityisesti tilanne, jossa pinon yläosassa oleva operaattori ja skannattu operaattori ovat molemmat ' ^ ‘. Tässä tilassa skannatun operaattorin etusija on korkeampi sen oikean assosiatiivisuuden vuoksi. Joten se työnnetään operaattoripinoon.
           • Kaikissa muissa tapauksissa, kun operaattoripinon yläosa on sama kuin skannattu operaattori, nosta operaattori pinosta vasemman assosiatiivisuuden vuoksi, jonka vuoksi skannatulla operaattorilla on vähemmän etusijaa.
         • Muussa tapauksessa pop kaikki operaattorit pinosta, jotka ovat suurempia tai yhtä suuria kuin skannatun operaattorin.
           • Tämän jälkeen Työnnä skannattu käyttäjä pinoon. (Jos kohtaat sulkeiden poksahduksen aikana, pysähdy siihen ja työnnä skannattu operaattori pinoon.)
      4. Alla on vaiheet yllä olevan idean toteuttamiseksi:
         1. Jos skannattu merkki on ' ( ', työnnä se pinoon.
         5. Alla on vaiheet yllä olevan idean toteuttamiseksi:
            1. Jos skannattu merkki on ' ) ', nosta pino ja tulosta se, kunnes ' ( ', ja hylkää molemmat sulut.
            6. Alla on vaiheet yllä olevan idean toteuttamiseksi:
               1. Toista vaiheet 2-5 kunnes infix-lauseke on skannattu.
               7. Alla on vaiheet yllä olevan idean toteuttamiseksi:

                  xvideoservicethief ubuntu 14.04 lataus

                  1. Kun skannaus on ohi, Popa pino ja lisää operaattorit postfix-lausekkeeseen, kunnes se ei ole tyhjä.
                  8. Alla on vaiheet yllä olevan idean toteuttamiseksi:
                     1. Tulosta lopuksi postfix-lauseke.

                     Alla on vaiheet yllä olevan idean toteuttamiseksi:

                     1. Kuva:

                     Alla on vaiheet yllä olevan idean toteuttamiseksi:

                     1. Seuraa alla olevaa kuvaa ymmärtääksesi paremmin
                        Alla on vaiheet yllä olevan idean toteuttamiseksi:

                        1. Harkitse infix-lauseketta exp = a+b*c+d
                           ja infix-lauseke skannataan iteraattorilla i , joka alustetaan nimellä i = 0 .

                           1. vaihe: Tässä i = 0 ja exp[i] = 'a' eli operandi. Joten lisää tämä postfix-lausekkeeseen. Siksi, postfix = a .

                           

                           Lisää 'a' postfixiin

                           2. vaihe: Tässä i = 1 ja exp[i] = '+' eli operaattori. Työnnä tämä pinoon. postfix = a ja pino = {+} .

                           

                           Paina '+' pinossa

                           3. vaihe: Nyt i = 2 ja exp[i] = 'b' eli operandi. Joten lisää tämä postfix-lausekkeeseen. postfix = ab ja pino = {+} .

                           

                           Lisää 'b' jälkiliitteeseen

                           4. vaihe: Nyt i = 3 ja exp[i] = '*' eli operaattori. Työnnä tämä pinoon. postfix = ab ja pino = {+, *} .

                           

                           Paina '*' pinossa

                           5. vaihe: Nyt i = 4 ja exp[i] = 'c' eli operandi. Lisää tämä postfix-lausekkeeseen. postfix = abc ja pino = {+, *} .

                           

                           Lisää 'c' postfixiin

                           6. vaihe: Nyt i = 5 ja exp[i] = '+' eli operaattori. Pinon ylimmällä elementillä on korkeampi prioriteetti. Joten pop, kunnes pino tyhjenee tai ylimmällä elementillä on vähemmän etusijaa. '*' on poksattu ja lisätty postfixiin. Niin postfix = abc* ja pino = {+} .

                           

                           Pop '*' ja lisää postfix

                           Nyt ylin elementti on ' + ' sillä ei myöskään ole vähemmän etusijaa. Puhkaise se. postfix = abc*+ .

                           

                           Valitse + ja lisää se postfixiin

                           Nyt pino on tyhjä. Joten työnnä '+' pinossa. pino = {+} .

                           

                           Paina '+' pinossa

                           7. vaihe: Nyt i = 6 ja exp[i] = 'd' eli operandi. Lisää tämä postfix-lausekkeeseen. postfix = abc*+d .

                           

                           Lisää jälkiliitteeseen 'd'.

                           Viimeinen vaihe: Nyt mitään elementtiä ei ole jäljellä. Joten tyhjennä pino ja lisää se postfix-lausekkeeseen. postfix = abc*+d+ .

                           

                           Valitse + ja lisää se postfixiin

                           Alla on yllä olevan algoritmin toteutus:

                           C

                           #include  #include  #include  // Function to return precedence of operators int prec(char c)  c == '-')  return 1;  else  return -1;  // Function to return associativity of operators char associativity(char c) {  if (c == '^')  return 'R';  return 'L'; // Default to left-associative } // The main function to convert infix expression to postfix expression void infixToPostfix(char s[]) {  char result[1000];  int resultIndex = 0;  int len = strlen(s);  char stack[1000];  int stackIndex = -1;  for (int i = 0; i < len; i++) {  char c = s[i];  // If the scanned character is an operand, add it to the output string.  if ((c>= 'a' && c<= 'z') || (c>= 'A' && c<= 'Z') || (c>= '0' && c<= '9')) {  result[resultIndex++] = c;  }  // If the scanned character is an ‘(‘, push it to the stack.  else if (c == '(') {  stack[++stackIndex] = c;  }  // If the scanned character is an ‘)’, pop and add to the output string from the stack  // until an ‘(‘ is encountered.  else if (c == ')') {  while (stackIndex>= 0 && pino[pinoindeksi] != '(') { tulos[tulosIndeksi++] = pino[pinoindeksi--];  } stackIndex--; // Pop '(' } // Jos operaattori skannataan else { while (stackIndex>= 0 && (prec(s[i])< prec(stack[stackIndex]) ||  prec(s[i]) == prec(stack[stackIndex]) &&  associativity(s[i]) == 'L')) {  result[resultIndex++] = stack[stackIndex--];  }  stack[++stackIndex] = c;  }  }  // Pop all the remaining elements from the stack  while (stackIndex>= 0) { tulos[tulosIndeksi++] = pino[pinoindeksi--];  } tulos[tulosindeksi] = ' ';  printf('%s
                           ', tulos); } // Ohjainkoodi int main() { char exp[] = 'a+b*(c^d-e)^(f+g*h)-i';  // Funktiokutsu infixToPostfix(exp);  paluu 0; }>

                           Java

                           import java.util.Stack; public class InfixToPostfix {  // Function to return precedence of operators  static int prec(char c)   // Function to return associativity of operators  static char associativity(char c) {  if (c == '^')  return 'R';  return 'L'; // Default to left-associative  }  // The main function to convert infix expression to postfix expression  static void infixToPostfix(String s) {  StringBuilder result = new StringBuilder();  Stackpino = new Pino();  for (int i = 0; i< s.length(); i++) {  char c = s.charAt(i);  // If the scanned character is an operand, add it to the output string.  if ((c>= 'a' && c<= 'z') || (c>= 'A' && c<= 'Z') || (c>= '0' && c<= '9')) {  result.append(c);  }  // If the scanned character is an ‘(‘, push it to the stack.  else if (c == '(') {  stack.push(c);  }  // If the scanned character is an ‘)’, pop and add to the output string from the stack  // until an ‘(‘ is encountered.  else if (c == ')') {  while (!stack.isEmpty() && stack.peek() != '(') {  result.append(stack.pop());  }  stack.pop(); // Pop '('  }  // If an operator is scanned  else {  while (!stack.isEmpty() && (prec(s.charAt(i)) < prec(stack.peek()) ||  prec(s.charAt(i)) == prec(stack.peek()) &&  associativity(s.charAt(i)) == 'L')) {  result.append(stack.pop());  }  stack.push(c);  }  }  // Pop all the remaining elements from the stack  while (!stack.isEmpty()) {  result.append(stack.pop());  }  System.out.println(result);  }  // Driver code  public static void main(String[] args) {  String exp = 'a+b*(c^d-e)^(f+g*h)-i';  // Function call  infixToPostfix(exp);  } }>

                           Python

                           def prec(c): if c == '^': return 3 elif c == '/' or c == '*': return 2 elif c == '+' or c == '-': return 1 else: return -1 def associativity(c): if c == '^': return 'R' return 'L' # Default to left-associative def infix_to_postfix(s): result = [] stack = [] for i in range(len(s)): c = s[i] # If the scanned character is an operand, add it to the output string. if ('a' <= c <= 'z') or ('A' <= c <= 'Z') or ('0' <= c <= '9'): result.append(c) # If the scanned character is an ‘(‘, push it to the stack. elif c == '(': stack.append(c) # If the scanned character is an ‘)’, pop and add to the output string from the stack # until an ‘(‘ is encountered. elif c == ')': while stack and stack[-1] != '(': result.append(stack.pop()) stack.pop() # Pop '(' # If an operator is scanned else: while stack and (prec(s[i]) < prec(stack[-1]) or (prec(s[i]) == prec(stack[-1]) and associativity(s[i]) == 'L')): result.append(stack.pop()) stack.append(c) # Pop all the remaining elements from the stack while stack: result.append(stack.pop()) print(''.join(result)) # Driver code exp = 'a+b*(c^d-e)^(f+g*h)-i' # Function call infix_to_postfix(exp)>

                           C#

                           using System; using System.Collections.Generic; class Program {  // Function to return precedence of operators  static int Prec(char c)   c == '*')  return 2;  else if (c == '+'   // Function to return associativity of operators  static char Associativity(char c)  {  if (c == '^')  return 'R';  return 'L'; // Default to left-associative  }  // The main function to convert infix expression to postfix expression  static void InfixToPostfix(string s)  {  Stackpino = uusi pino();  Listatulos = uusi lista();  for (int i = 0; i< s.Length; i++)  {  char c = s[i];  // If the scanned character is an operand, add it to the output string.  if ((c>= 'a' && c<= 'z') || (c>= 'A' && c<= 'Z') || (c>= '0' && c<= '9'))  {  result.Add(c);  }  // If the scanned character is an ‘(‘, push it to the stack.  else if (c == '(')  {  stack.Push(c);  }  // If the scanned character is an ‘)’, pop and add to the output string from the stack  // until an ‘(‘ is encountered.  else if (c == ')')  {  while (stack.Count>0 && pino.Peek() != '(') { tulos.Lisää(pino.Pop());  } pino.Pop(); // Pop '(' } // Jos operaattori skannataan else { while (pino.Laskuri> 0 && (Prec(s[i])< Prec(stack.Peek()) ||  Prec(s[i]) == Prec(stack.Peek()) &&  Associativity(s[i]) == 'L'))  {  result.Add(stack.Pop());  }  stack.Push(c);  }  }  // Pop all the remaining elements from the stack  while (stack.Count>0) { tulos.Lisää(pino.Pop());  } Console.WriteLine(string.Join('', tulos));  } // Ohjainkoodi static void Main() { string exp = 'a+b*(c^d-e)^(f+g*h)-i';  // Funktiokutsu InfixToPostfix(exp);  } }>

                           Javascript

                            /* Javascript implementation to convert  infix expression to postfix*/    //Function to return precedence of operators  function prec(c)  c == '-')  return 1;  else  return -1;    // The main function to convert infix expression  //to postfix expression  function infixToPostfix(s) {  let st = []; //For stack operations, we are using JavaScript built in stack  let result = '';  for(let i = 0; i < s.length; i++) {  let c = s[i];  // If the scanned character is  // an operand, add it to output string.  if((c>= 'a' && c<= 'z') || (c>= 'A' && c<= 'Z') || (c>= '0' && c<= '9'))  result += c;  // If the scanned character is an  // ‘(‘, push it to the stack.  else if(c == '(')  st.push('(');  // If the scanned character is an ‘)’,  // pop and to output string from the stack  // until an ‘(‘ is encountered.  else if(c == ')') {  while(st[st.length - 1] != '(')  {  result += st[st.length - 1];  st.pop();  }  st.pop();  }  //If an operator is scanned  else {  while(st.length != 0 && prec(s[i]) <= prec(st[st.length - 1])) {  result += st[st.length - 1];  st.pop();   }  st.push(c);  }  }  // Pop all the remaining elements from the stack  while(st.length != 0) {  result += st[st.length - 1];  st.pop();  }  console.log(result + '');  }    let exp = 'a+b*(c^d-e)^(f+g*h)-i';  infixToPostfix(exp); // This code is contributed by decode2207.>

                           C++14

                           #include  using namespace std; // Function to return precedence of operators int prec(char c)  c == '*')  return 2;  else if (c == '+'  // Function to return associativity of operators char associativity(char c) {  if (c == '^')  return 'R';  return 'L'; // Default to left-associative } // The main function to convert infix expression // to postfix expression void infixToPostfix(string s) {  stackst;  merkkijono tulos;  for (int i = 0; i< s.length(); i++) {  char c = s[i];  // If the scanned character is  // an operand, add it to the output string.  if ((c>= 'a' && c<= 'z') || (c>= 'A' && c<= 'Z') || (c>= '0' && c<= '9'))  result += c;  // If the scanned character is an  // ‘(‘, push it to the stack.  else if (c == '(')  st.push('(');  // If the scanned character is an ‘)’,  // pop and add to the output string from the stack  // until an ‘(‘ is encountered.  else if (c == ')') {  while (st.top() != '(') {  result += st.top();  st.pop();  }  st.pop(); // Pop '('  }  // If an operator is scanned  else {  while (!st.empty() && prec(s[i]) < prec(st.top()) ||  !st.empty() && prec(s[i]) == prec(st.top()) &&  associativity(s[i]) == 'L') {  result += st.top();  st.pop();  }  st.push(c);  }  }  // Pop all the remaining elements from the stack  while (!st.empty()) {  result += st.top();  st.pop();  }  cout << result << endl; } // Driver code int main() {  string exp = 'a+b*(c^d-e)^(f+g*h)-i';  // Function call  infixToPostfix(exp);  return 0; }>

                           
                           Lähtö

                           abcd^e-fgh*+^*+i->

                           Aika monimutkaisuus: O(N), missä N on infiksilausekkeen koko
                           Aputila: O(N), missä N on infiksilausekkeen koko