Academic Integrity: tutoring, explanations, and feedback — we don’t complete graded work or submit on a student’s behalf.

JAVA: Using LinkedBinaryTree implementation, write a program that reads fully pa

ID: 3854740 • Letter: J

Question

JAVA:

Using LinkedBinaryTree implementation, write a program that reads fully parenthesized, arithmetic expressions from a file and converts them into binary expression trees.

Add a method named eulerTourBinary, Write this method so that it will print out a traditional parenthesized arithmetic expression. Your program should Ask the user to enter the absolute path and filename (as a single String) of the file that contains a list of arithmetic expressions. Each expression will be on a single line in the input text file delimited by and end of line character. Read arithmetic expressions from an input file until the EOF is reached - o See file format and example at end of assignment. For each expression your program should: Print out the expression that was read from the file Determine if the expression is valid. o o Print an invalid expression message for invalid expressions. For each valid expression " Represent the expression in a binary expression tree Evaluate the expression and display the results of the evaluation Display the contents of the binary expression tree using: o o o o A preorder traversal Aninorder traversal A postorder traversal The euler TourBinary method that you added for this Lab Each traversal should be appropriately labland print out on a single lin In the input file each value or operand will be space separated. e.g. a negative number value will be written as -5 without a space between the- and the '5'

Explanation / Answer

  1.  /** 
  2.   ** Java Program to Implement Shunting Yard Algorithm 
  3.   **/ 
  4.    
  5.  import java.util.Scanner; 
  6.    
  7.  /** Class ShuntingYard **/ 
  8.  public class ShuntingYard 
  9.  { 
  10.      /** enum **/ 
  11.      private enum Precedence 
  12.      { 
  13.          lparen(0), rparen(1), plus(2), minus(3), divide(4), times(5), mod(6), eos(7), operand(8); 
  14.    
  15.          private int index; 
  16.          Precedence(int index) 
  17.          { 
  18.              this.index = index; 
  19.          } 
  20.          public int getIndex() 
  21.          { 
  22.              return index; 
  23.          }         
  24.      }  
  25.      /** in stack precedence **/ 
  26.      private static final int[] isp = {0, 19, 12, 12, 13, 13, 13, 0}; 
  27.      /** incoming character precedence **/ 
  28.      private static final int[] icp = {20, 19, 12, 12, 13, 13, 13, 0}; 
  29.      /** operators **/ 
  30.      private static final char[] operators = {'{', '}', '+', '-', '/', '*', '%', ' '}; 
  31.      /** precedence stack **/ 
  32.      private Precedence[] stack;  
  33.      /** stack top pointer **/ 
  34.      private int top; 
  35.    
  36.      /** pop element from stack **/ 
  37.      private Precedence pop() 
  38.      { 
  39.          return stack[top--]; 
  40.      } 
  41.      /** push element onto stack **/ 
  42.      private void push(Precedence ele) 
  43.      { 
  44.          stack[++top] = ele; 
  45.      } 
  46.      /** get precedence token for symbol **/ 
  47.      public Precedence getToken(char symbol) 
  48.      { 
  49.          switch (symbol) 
  50.          { 
  51.          case '('  : return Precedence.lparen; 
  52.          case ')'  : return Precedence.rparen; 
  53.          case '+'  : return Precedence.plus; 
  54.          case '-'  : return Precedence.minus; 
  55.          case '/'  : return Precedence.divide; 
  56.          case '*'  : return Precedence.times; 
  57.          case '%'  : return Precedence.mod; 
  58.          case ' '  : return Precedence.eos; 
  59.          default   : return Precedence.operand; 
  60.          } 
  61.      } 
  62.    
  63.      /** Function to convert infix to postfix **/ 
  64.      public String postfix(String infix) 
  65.      { 
  66.          String postfix = ""; 
  67.          top = 0; 
  68.          stack = new Precedence[infix.length()]; 
  69.          stack[0] = Precedence.eos; 
  70.          Precedence token; 
  71.          for (int i = 0; i < infix.length(); i++) 
  72.          { 
  73.              token = getToken(infix.charAt(i)); 
  74.              /** if token is operand append to postfix **/ 
  75.              if (token == Precedence.operand) 
  76.                  postfix = postfix + infix.charAt(i); 
  77.              /** if token is right parenthesis pop till matching left parenthesis **/ 
  78.              else if (token == Precedence.rparen) 
  79.              { 
  80.                  while (stack[top] != Precedence.lparen) 
  81.                      postfix = postfix + operators[pop().getIndex()]; 
  82.                  /** discard left parenthesis **/ 
  83.                  pop(); 
  84.              } 
  85.              /** else pop stack elements whose precedence is greater than that of token **/ 
  86.              else 
  87.              { 
  88.                  while (isp[stack[top].getIndex()] >= icp[token.getIndex()]) 
  89.                      postfix = postfix + operators[pop().getIndex()]; 
  90.                  push(token); 
  91.              } 
  92.          } 
  93.          /** pop any remaining elements in stack **/ 
  94.          while ((token = pop()) != Precedence.eos) 
  95.              postfix = postfix + operators[token.getIndex()]; 
  96.    
  97.          return postfix; 
  98.      } 
  99.      /** Main function **/ 
  100.      public static void main (String[] args)  
  101.      { 
  102.          Scanner scan = new Scanner(System.in); 
  103.          System.out.println("Shunting Yard Algorithm Test "); 
  104.          /** Make an object of ShuntingYard class **/ 
  105.          ShuntingYard sy = new ShuntingYard(); 
  106.    
  107.          /** Accept infix expression **/ 
  108.          System.out.println("Enter infix expression"); 
  109.          String infix = scan.next(); 
  110.    
  111.          String postfix = sy.postfix(infix); 
  112.          System.out.println(" Postfix expression : "+ postfix); 
  113.      } 
  114.  } 
  1.  /** 
  2.   ** Java Program to Implement Shunting Yard Algorithm 
  3.   **/ 
  4.    
  5.  import java.util.Scanner; 
  6.    
  7.  /** Class ShuntingYard **/ 
  8.  public class ShuntingYard 
  9.  { 
  10.      /** enum **/ 
  11.      private enum Precedence 
  12.      { 
  13.          lparen(0), rparen(1), plus(2), minus(3), divide(4), times(5), mod(6), eos(7), operand(8); 
  14.    
  15.          private int index; 
  16.          Precedence(int index) 
  17.          { 
  18.              this.index = index; 
  19.          } 
  20.          public int getIndex() 
  21.          { 
  22.              return index; 
  23.          }         
  24.      }  
  25.      /** in stack precedence **/ 
  26.      private static final int[] isp = {0, 19, 12, 12, 13, 13, 13, 0}; 
  27.      /** incoming character precedence **/ 
  28.      private static final int[] icp = {20, 19, 12, 12, 13, 13, 13, 0}; 
  29.      /** operators **/ 
  30.      private static final char[] operators = {'{', '}', '+', '-', '/', '*', '%', ' '}; 
  31.      /** precedence stack **/ 
  32.      private Precedence[] stack;  
  33.      /** stack top pointer **/ 
  34.      private int top; 
  35.    
  36.      /** pop element from stack **/ 
  37.      private Precedence pop() 
  38.      { 
  39.          return stack[top--]; 
  40.      } 
  41.      /** push element onto stack **/ 
  42.      private void push(Precedence ele) 
  43.      { 
  44.          stack[++top] = ele; 
  45.      } 
  46.      /** get precedence token for symbol **/ 
  47.      public Precedence getToken(char symbol) 
  48.      { 
  49.          switch (symbol) 
  50.          { 
  51.          case '('  : return Precedence.lparen; 
  52.          case ')'  : return Precedence.rparen; 
  53.          case '+'  : return Precedence.plus; 
  54.          case '-'  : return Precedence.minus; 
  55.          case '/'  : return Precedence.divide; 
  56.          case '*'  : return Precedence.times; 
  57.          case '%'  : return Precedence.mod; 
  58.          case ' '  : return Precedence.eos; 
  59.          default   : return Precedence.operand; 
  60.          } 
  61.      } 
  62.    
  63.      /** Function to convert infix to postfix **/ 
  64.      public String postfix(String infix) 
  65.      { 
  66.          String postfix = ""; 
  67.          top = 0; 
  68.          stack = new Precedence[infix.length()]; 
  69.          stack[0] = Precedence.eos; 
  70.          Precedence token; 
  71.          for (int i = 0; i < infix.length(); i++) 
  72.          { 
  73.              token = getToken(infix.charAt(i)); 
  74.              /** if token is operand append to postfix **/ 
  75.              if (token == Precedence.operand) 
  76.                  postfix = postfix + infix.charAt(i); 
  77.              /** if token is right parenthesis pop till matching left parenthesis **/ 
  78.              else if (token == Precedence.rparen) 
  79.              { 
  80.                  while (stack[top] != Precedence.lparen) 
  81.                      postfix = postfix + operators[pop().getIndex()]; 
  82.                  /** discard left parenthesis **/ 
  83.                  pop(); 
  84.              } 
  85.              /** else pop stack elements whose precedence is greater than that of token **/ 
  86.              else 
  87.              { 
  88.                  while (isp[stack[top].getIndex()] >= icp[token.getIndex()]) 
  89.                      postfix = postfix + operators[pop().getIndex()]; 
  90.                  push(token); 
  91.              } 
  92.          } 
  93.          /** pop any remaining elements in stack **/ 
  94.          while ((token = pop()) != Precedence.eos) 
  95.              postfix = postfix + operators[token.getIndex()]; 
  96.    
  97.          return postfix; 
  98.      } 
  99.      /** Main function **/ 
  100.      public static void main (String[] args)  
  101.      { 
  102.          Scanner scan = new Scanner(System.in); 
  103.          System.out.println("Shunting Yard Algorithm Test "); 
  104.          /** Make an object of ShuntingYard class **/ 
  105.          ShuntingYard sy = new ShuntingYard(); 
  106.    
  107.          /** Accept infix expression **/ 
  108.          System.out.println("Enter infix expression"); 
  109.          String infix = scan.next(); 
  110.    
  111.          String postfix = sy.postfix(infix); 
  112.          System.out.println(" Postfix expression : "+ postfix); 
  113.      } 
  114.  } 
  1.  /** 
  2.   ** Java Program to Implement Shunting Yard Algorithm 
  3.   **/ 
  4.    
  5.  import java.util.Scanner; 
  6.    
  7.  /** Class ShuntingYard **/ 
  8.  public class ShuntingYard 
  9.  { 
  10.      /** enum **/ 
  11.      private enum Precedence 
  12.      { 
  13.          lparen(0), rparen(1), plus(2), minus(3), divide(4), times(5), mod(6), eos(7), operand(8); 
  14.    
  15.          private int index; 
  16.          Precedence(int index) 
  17.          { 
  18.              this.index = index; 
  19.          } 
  20.          public int getIndex() 
  21.          { 
  22.              return index; 
  23.          }         
  24.      }  
  25.      /** in stack precedence **/ 
  26.      private static final int[] isp = {0, 19, 12, 12, 13, 13, 13, 0}; 
  27.      /** incoming character precedence **/ 
  28.      private static final int[] icp = {20, 19, 12, 12, 13, 13, 13, 0}; 
  29.      /** operators **/ 
  30.      private static final char[] operators = {'{', '}', '+', '-', '/', '*', '%', ' '}; 
  31.      /** precedence stack **/ 
  32.      private Precedence[] stack;  
  33.      /** stack top pointer **/ 
  34.      private int top; 
  35.    
  36.      /** pop element from stack **/ 
  37.      private Precedence pop() 
  38.      { 
  39.          return stack[top--]; 
  40.      } 
  41.      /** push element onto stack **/ 
  42.      private void push(Precedence ele) 
  43.      { 
  44.          stack[++top] = ele; 
  45.      } 
  46.      /** get precedence token for symbol **/ 
  47.      public Precedence getToken(char symbol) 
  48.      { 
  49.          switch (symbol) 
  50.          { 
  51.          case '('  : return Precedence.lparen; 
  52.          case ')'  : return Precedence.rparen; 
  53.          case '+'  : return Precedence.plus; 
  54.          case '-'  : return Precedence.minus; 
  55.          case '/'  : return Precedence.divide; 
  56.          case '*'  : return Precedence.times; 
  57.          case '%'  : return Precedence.mod; 
  58.          case ' '  : return Precedence.eos; 
  59.          default   : return Precedence.operand; 
  60.          } 
  61.      } 
  62.    
  63.      /** Function to convert infix to postfix **/ 
  64.      public String postfix(String infix) 
  65.      { 
  66.          String postfix = ""; 
  67.          top = 0; 
  68.          stack = new Precedence[infix.length()]; 
  69.          stack[0] = Precedence.eos; 
  70.          Precedence token; 
  71.          for (int i = 0; i < infix.length(); i++) 
  72.          { 
  73.              token = getToken(infix.charAt(i)); 
  74.              /** if token is operand append to postfix **/ 
  75.              if (token == Precedence.operand) 
  76.                  postfix = postfix + infix.charAt(i); 
  77.              /** if token is right parenthesis pop till matching left parenthesis **/ 
  78.              else if (token == Precedence.rparen) 
  79.              { 
  80.                  while (stack[top] != Precedence.lparen) 
  81.                      postfix = postfix + operators[pop().getIndex()]; 
  82.                  /** discard left parenthesis **/ 
  83.                  pop(); 
  84.              } 
  85.              /** else pop stack elements whose precedence is greater than that of token **/ 
  86.              else 
  87.              { 
  88.                  while (isp[stack[top].getIndex()] >= icp[token.getIndex()]) 
  89.                      postfix = postfix + operators[pop().getIndex()]; 
  90.                  push(token); 
  91.              } 
  92.          } 
  93.          /** pop any remaining elements in stack **/ 
  94.          while ((token = pop()) != Precedence.eos) 
  95.              postfix = postfix + operators[token.getIndex()]; 
  96.    
  97.          return postfix; 
  98.      } 
  99.      /** Main function **/ 
  100.      public static void main (String[] args)  
  101.      { 
  102.          Scanner scan = new Scanner(System.in); 
  103.          System.out.println("Shunting Yard Algorithm Test "); 
  104.          /** Make an object of ShuntingYard class **/ 
  105.          ShuntingYard sy = new ShuntingYard(); 
  106.    
  107.          /** Accept infix expression **/ 
  108.          System.out.println("Enter infix expression"); 
  109.          String infix = scan.next(); 
  110.    
  111.          String postfix = sy.postfix(infix); 
  112.          System.out.println(" Postfix expression : "+ postfix); 
  113.      } 
  114.  } 
  1.  /** 
  2.   ** Java Program to Implement Shunting Yard Algorithm 
  3.   **/ 
  4.    
  5.  import java.util.Scanner; 
  6.    
  7.  /** Class ShuntingYard **/ 
  8.  public class ShuntingYard 
  9.  { 
  10.      /** enum **/ 
  11.      private enum Precedence 
  12.      { 
  13.          lparen(0), rparen(1), plus(2), minus(3), divide(4), times(5), mod(6), eos(7), operand(8); 
  14.    
  15.          private int index; 
  16.          Precedence(int index) 
  17.          { 
  18.              this.index = index; 
  19.          } 
  20.          public int getIndex() 
  21.          { 
  22.              return index; 
  23.          }         
  24.      }  
  25.      /** in stack precedence **/ 
  26.      private static final int[] isp = {0, 19, 12, 12, 13, 13, 13, 0}; 
  27.      /** incoming character precedence **/ 
  28.      private static final int[] icp = {20, 19, 12, 12, 13, 13, 13, 0}; 
  29.      /** operators **/ 
  30.      private static final char[] operators = {'{', '}', '+', '-', '/', '*', '%', ' '}; 
  31.      /** precedence stack **/ 
  32.      private Precedence[] stack;  
  33.      /** stack top pointer **/ 
  34.      private int top; 
  35.    
  36.      /** pop element from stack **/ 
  37.      private Precedence pop() 
  38.      { 
  39.          return stack[top--]; 
  40.      } 
  41.      /** push element onto stack **/ 
  42.      private void push(Precedence ele) 
  43.      { 
  44.          stack[++top] = ele; 
  45.      } 
  46.      /** get precedence token for symbol **/ 
  47.      public Precedence getToken(char symbol) 
  48.      { 
  49.          switch (symbol) 
  50.          { 
  51.          case '('  : return Precedence.lparen; 
  52.          case ')'  : return Precedence.rparen; 
  53.          case '+'  : return Precedence.plus; 
  54.          case '-'  : return Precedence.minus; 
  55.          case '/'  : return Precedence.divide; 
  56.          case '*'  : return Precedence.times; 
  57.          case '%'  : return Precedence.mod; 
  58.          case ' '  : return Precedence.eos; 
  59.          default   : return Precedence.operand; 
  60.          } 
  61.      } 
  62.    
  63.      /** Function to convert infix to postfix **/ 
  64.      public String postfix(String infix) 
  65.      { 
  66.          String postfix = ""; 
  67.          top = 0; 
  68.          stack = new Precedence[infix.length()]; 
  69.          stack[0] = Precedence.eos; 
  70.          Precedence token; 
  71.          for (int i = 0; i < infix.length(); i++) 
  72.          { 
  73.              token = getToken(infix.charAt(i)); 
  74.              /** if token is operand append to postfix **/ 
  75.              if (token == Precedence.operand) 
  76.                  postfix = postfix + infix.charAt(i); 
  77.              /** if token is right parenthesis pop till matching left parenthesis **/ 
  78.              else if (token == Precedence.rparen) 
  79.              { 
  80.                  while (stack[top] != Precedence.lparen) 
  81.                      postfix = postfix + operators[pop().getIndex()]; 
  82.                  /** discard left parenthesis **/ 
  83.                  pop(); 
  84.              } 
  85.              /** else pop stack elements whose precedence is greater than that of token **/ 
  86.              else 
  87.              { 
  88.                  while (isp[stack[top].getIndex()] >= icp[token.getIndex()]) 
  89.                      postfix = postfix + operators[pop().getIndex()]; 
  90.                  push(token); 
  91.              } 
  92.          } 
  93.          /** pop any remaining elements in stack **/ 
  94.          while ((token = pop()) != Precedence.eos) 
  95.              postfix = postfix + operators[token.getIndex()]; 
  96.    
  97.          return postfix; 
  98.      } 
  99.      /** Main function **/ 
  100.      public static void main (String[] args)  
  101.      { 
  102.          Scanner scan = new Scanner(System.in); 
  103.          System.out.println("Shunting Yard Algorithm Test "); 
  104.          /** Make an object of ShuntingYard class **/ 
  105.          ShuntingYard sy = new ShuntingYard(); 
  106.    
  107.          /** Accept infix expression **/ 
  108.          System.out.println("Enter infix expression"); 
  109.          String infix = scan.next(); 
  110.    
  111.          String postfix = sy.postfix(infix); 
  112.          System.out.println(" Postfix expression : "+ postfix); 
  113.      } 
  114.  } 
  1.  /** 
  2.   ** Java Program to Implement Shunting Yard Algorithm 
  3.   **/ 
  4.    
  5.  import java.util.Scanner; 
  6.    
  7.  /** Class ShuntingYard **/ 
  8.  public class ShuntingYard 
  9.  { 
  10.      /** enum **/ 
  11.      private enum Precedence 
  12.      { 
  13.          lparen(0), rparen(1), plus(2), minus(3), divide(4), times(5), mod(6), eos(7), operand(8); 
  14.    
  15.          private int index; 
  16.          Precedence(int index) 
  17.          { 
  18.              this.index = index; 
  19.          } 
  20.          public int getIndex() 
  21.          { 
  22.              return index; 
  23.          }         
  24.      }  
  25.      /** in stack precedence **/ 
  26.      private static final int[] isp = {0, 19, 12, 12, 13, 13, 13, 0}; 
  27.      /** incoming character precedence **/ 
  28.      private static final int[] icp = {20, 19, 12, 12, 13, 13, 13, 0}; 
  29.      /** operators **/ 
  30.      private static final char[] operators = {'{', '}', '+', '-', '/', '*', '%', ' '}; 
  31.      /** precedence stack **/ 
  32.      private Precedence[] stack;  
  33.      /** stack top pointer **/ 
  34.      private int top; 
  35.    
  36.      /** pop element from stack **/ 
  37.      private Precedence pop() 
  38.      { 
  39.          return stack[top--]; 
  40.      } 
  41.      /** push element onto stack **/ 
  42.      private void push(Precedence ele) 
  43.      { 
  44.          stack[++top] = ele; 
  45.      } 
  46.      /** get precedence token for symbol **/ 
  47.      public Precedence getToken(char symbol) 
  48.      { 
  49.          switch (symbol) 
  50.          { 
  51.          case '('  : return Precedence.lparen; 
  52.          case ')'  : return Precedence.rparen; 
  53.          case '+'  : return Precedence.plus; 
  54.          case '-'  : return Precedence.minus; 
  55.          case '/'  : return Precedence.divide; 
  56.          case '*'  : return Precedence.times; 
  57.          case '%'  : return Precedence.mod; 
  58.          case ' '  : return Precedence.eos; 
  59.          default   : return Precedence.operand; 
  60.          } 
  61.      } 
  62.    
  63.      /** Function to convert infix to postfix **/ 
  64.      public String postfix(String infix) 
  65.      { 
  66.          String postfix = ""; 
  67.          top = 0; 
  68.          stack = new Precedence[infix.length()]; 
  69.          stack[0] = Precedence.eos; 
  70.          Precedence token; 
  71.          for (int i = 0; i < infix.length(); i++) 
  72.          { 
  73.              token = getToken(infix.charAt(i)); 
  74.              /** if token is operand append to postfix **/ 
  75.              if (token == Precedence.operand) 
  76.                  postfix = postfix + infix.charAt(i); 
  77.              /** if token is right parenthesis pop till matching left parenthesis **/ 
  78.              else if (token == Precedence.rparen) 
  79.              { 
  80.                  while (stack[top] != Precedence.lparen) 
  81.                      postfix = postfix + operators[pop().getIndex()]; 
  82.                  /** discard left parenthesis **/ 
  83.                  pop(); 
  84.              } 
  85.              /** else pop stack elements whose precedence is greater than that of token **/ 
  86.              else 
  87.              { 
  88.                  while (isp[stack[top].getIndex()] >= icp[token.getIndex()]) 
  89.                      postfix = postfix + operators[pop().getIndex()]; 
  90.                  push(token); 
  91.              } 
  92.          } 
  93.          /** pop any remaining elements in stack **/ 
  94.          while ((token = pop()) != Precedence.eos) 
  95.              postfix = postfix + operators[token.getIndex()]; 
  96.    
  97.          return postfix; 
  98.      } 
  99.      /** Main function **/ 
  100.      public static void main (String[] args)  
  101.      { 
  102.          Scanner scan = new Scanner(System.in); 
  103.          System.out.println("Shunting Yard Algorithm Test "); 
  104.          /** Make an object of ShuntingYard class **/ 
  105.          ShuntingYard sy = new ShuntingYard(); 
  106.    
  107.          /** Accept infix expression **/ 
  108.          System.out.println("Enter infix expression"); 
  109.          String infix = scan.next(); 
  110.    
  111.          String postfix = sy.postfix(infix); 
  112.          System.out.println(" Postfix expression : "+ postfix); 
  113.      } 
  114.  } 
  1.  /** 
  2.   ** Java Program to Implement Shunting Yard Algorithm 
  3.   **/ 
  4.    
  5.  import java.util.Scanner; 
  6.    
  7.  /** Class ShuntingYard **/ 
  8.  public class ShuntingYard 
  9.  { 
  10.      /** enum **/ 
  11.      private enum Precedence 
  12.      { 
  13.          lparen(0), rparen(1), plus(2), minus(3), divide(4), times(5), mod(6), eos(7), operand(8); 
  14.    
  15.          private int index; 
  16.          Precedence(int index) 
  17.          { 
  18.              this.index = index; 
  19.          } 
  20.          public int getIndex() 
  21.          { 
  22.              return index; 
  23.          }         
  24.      }  
  25.      /** in stack precedence **/ 
  26.      private static final int[] isp = {0, 19, 12, 12, 13, 13, 13, 0}; 
  27.      /** incoming character precedence **/ 
  28.      private static final int[] icp = {20, 19, 12, 12, 13, 13, 13, 0}; 
  29.      /** operators **/ 
  30.      private static final char[] operators = {'{', '}', '+', '-', '/', '*', '%', ' '}; 
  31.      /** precedence stack **/ 
  32.      private Precedence[] stack;  
  33.      /** stack top pointer **/ 
  34.      private int top; 
  35.    
  36.      /** pop element from stack **/ 
  37.      private Precedence pop() 
  38.      { 
  39.          return stack[top--]; 
  40.      } 
  41.      /** push element onto stack **/ 
  42.      private void push(Precedence ele) 
  43.      { 
  44.          stack[++top] = ele; 
  45.      } 
  46.      /** get precedence token for symbol **/ 
  47.      public Precedence getToken(char symbol) 
  48.      { 
  49.          switch (symbol) 
  50.          { 
  51.          case '('  : return Precedence.lparen; 
  52.          case ')'  : return Precedence.rparen; 
  53.          case '+'  : return Precedence.plus; 
  54.          case '-'  : return Precedence.minus; 
  55.          case '/'  : return Precedence.divide; 
  56.          case '*'  : return Precedence.times; 
  57.          case '%'  : return Precedence.mod; 
  58.          case ' '  : return Precedence.eos; 
  59.          default   : return Precedence.operand; 
  60.          } 
  61.      } 
  62.    
  63.      /** Function to convert infix to postfix **/ 
  64.      public String postfix(String infix) 
  65.      { 
  66.          String postfix = ""; 
  67.          top = 0; 
  68.          stack = new Precedence[infix.length()]; 
  69.          stack[0] = Precedence.eos; 
  70.          Precedence token; 
  71.          for (int i = 0; i < infix.length(); i++) 
  72.          { 
  73.              token = getToken(infix.charAt(i)); 
  74.              /** if token is operand append to postfix **/ 
  75.              if (token == Precedence.operand) 
  76.                  postfix = postfix + infix.charAt(i); 
  77.              /** if token is right parenthesis pop till matching left parenthesis **/ 
  78.              else if (token == Precedence.rparen) 
  79.              { 
  80.                  while (stack[top] != Precedence.lparen) 
  81.                      postfix = postfix + operators[pop().getIndex()]; 
  82.                  /** discard left parenthesis **/ 
  83.                  pop(); 
  84.              } 
  85.              /** else pop stack elements whose precedence is greater than that of token **/ 
  86.              else 
  87.              { 
  88.                  while (isp[stack[top].getIndex()] >= icp[token.getIndex()]) 
  89.                      postfix = postfix + operators[pop().getIndex()]; 
  90.                  push(token); 
  91.              } 
  92.          } 
  93.          /** pop any remaining elements in stack **/ 
  94.          while ((token = pop()) != Precedence.eos) 
  95.              postfix = postfix + operators[token.getIndex()]; 
  96.    
  97.          return postfix; 
  98.      } 
  99.      /** Main function **/ 
  100.      public static void main (String[] args)  
  101.      { 
  102.          Scanner scan = new Scanner(System.in); 
  103.          System.out.println("Shunting Yard Algorithm Test "); 
  104.          /** Make an object of ShuntingYard class **/ 
  105.          ShuntingYard sy = new ShuntingYard(); 
  106.    
  107.          /** Accept infix expression **/ 
  108.          System.out.println("Enter infix expression"); 
  109.          String infix = scan.next(); 
  110.    
  111.          String postfix = sy.postfix(infix); 
  112.          System.out.println(" Postfix expression : "+ postfix); 
  113.      } 
  114.  } 
  1.  /** 
  2.   ** Java Program to Implement Shunting Yard Algorithm 
  3.   **/ 
  4.    
  5.  import java.util.Scanner; 
  6.    
  7.  /** Class ShuntingYard **/ 
  8.  public class ShuntingYard 
  9.  { 
  10.      /** enum **/ 
  11.      private enum Precedence 
  12.      { 
  13.          lparen(0), rparen(1), plus(2), minus(3), divide(4), times(5), mod(6), eos(7), operand(8); 
  14.    
  15.          private int index; 
  16.          Precedence(int index) 
  17.          { 
  18.              this.index = index; 
  19.          } 
  20.          public int getIndex() 
  21.          { 
  22.              return index; 
  23.          }         
  24.      }  
  25.      /** in stack precedence **/ 
  26.      private static final int[] isp = {0, 19, 12, 12, 13, 13, 13, 0}; 
  27.      /** incoming character precedence **/ 
  28.      private static final int[] icp = {20, 19, 12, 12, 13, 13, 13, 0}; 
  29.      /** operators **/ 
  30.      private static final char[] operators = {'{', '}', '+', '-', '/', '*', '%', ' '}; 
  31.      /** precedence stack **/ 
  32.      private Precedence[] stack;  
  33.      /** stack top pointer **/ 
  34.      private int top; 
  35.    
  36.      /** pop element from stack **/ 
  37.      private Precedence pop() 
  38.      { 
  39.          return stack[top--]; 
  40.      } 
  41.      /** push element onto stack **/ 
  42.      private void push(Precedence ele) 
  43.      { 
  44.          stack[++top] = ele; 
  45.      } 
  46.      /** get precedence token for symbol **/ 
  47.      public Precedence getToken(char symbol) 
  48.      { 
  49.          switch (symbol) 
  50.          { 
  51.          case '('  : return Precedence.lparen; 
  52.          case ')'  : return Precedence.rparen; 
  53.          case '+'  : return Precedence.plus; 
  54.          case '-'  : return Precedence.minus; 
  55.          case '/'  : return Precedence.divide; 
  56.          case '*'  : return Precedence.times; 
  57.          case '%'  : return Precedence.mod; 
  58.          case ' '  : return Precedence.eos; 
  59.          default   : return Precedence.operand; 
  60.          } 
  61.      } 
  62.    
  63.      /** Function to convert infix to postfix **/ 
  64.      public String postfix(String infix) 
  65.      { 
  66.          String postfix = ""; 
  67.          top = 0; 
  68.          stack = new Precedence[infix.length()]; 
  69.          stack[0] = Precedence.eos; 
  70.          Precedence token; 
  71.          for (int i = 0; i < infix.length(); i++) 
  72.          { 
  73.              token = getToken(infix.charAt(i)); 
  74.              /** if token is operand append to postfix **/ 
  75.              if (token == Precedence.operand) 
  76.                  postfix = postfix + infix.charAt(i); 
  77.              /** if token is right parenthesis pop till matching left parenthesis **/ 
  78.              else if (token == Precedence.rparen) 
  79.              { 
  80.                  while (stack[top] != Precedence.lparen) 
  81.                      postfix = postfix + operators[pop().getIndex()]; 
  82.                  /** discard left parenthesis **/ 
  83.                  pop(); 
  84.              } 
  85.              /** else pop stack elements whose precedence is greater than that of token **/ 
  86.              else 
  87.              { 
  88.                  while (isp[stack[top].getIndex()] >= icp[token.getIndex()]) 
  89.                      postfix = postfix + operators[pop().getIndex()]; 
  90.                  push(token); 
  91.              } 
  92.          } 
  93.          /** pop any remaining elements in stack **/ 
  94.          while ((token = pop()) != Precedence.eos) 
  95.              postfix = postfix + operators[token.getIndex()]; 
  96.    
  97.          return postfix; 
  98.      } 
  99.      /** Main function **/ 
  100.      public static void main (String[] args)  
  101.      { 
  102.          Scanner scan = new Scanner(System.in); 
  103.          System.out.println("Shunting Yard Algorithm Test "); 
  104.          /** Make an object of ShuntingYard class **/ 
  105.          ShuntingYard sy = new ShuntingYard(); 
  106.    
  107.          /** Accept infix expression **/ 
  108.          System.out.println("Enter infix expression"); 
  109.          String infix = scan.next(); 
  110.    
  111.          String postfix = sy.postfix(infix); 
  112.          System.out.println(" Postfix expression : "+ postfix); 
  113.      } 
  114.  }

Related Questions

JAVA: For this project, you will create a GUI drawing application. *The user can
Question #654195
JAVA: HELP!!! You\'ve been hired by Cube Counters to write a Java console applic
Question #3930334
JAVA: Here is a recursive method that returns the smallest character in a string
Question #3846428
JAVA: Hi I am having trouble getting a basic sorting method to work into my code
Question #3666898
JAVA: Hi, I need help with my program. I need to edit my code so that everytime
Question #3671481
JAVA: How can I find the average yearly salary of all employees for each year(20
Question #3876754
JAVA: How to add a timer to this code? All I need it to do is count and print th
Question #3924534
JAVA: How to make a driver for this super class and its two subclasses? You are
Question #3935859

Navigate

Previous
JAVA: Use text file to Create a .java file that reads in this file into an array
Next
JAVA: WRITE IN \"SWITCH-STATEMENT!\" THIS CODE NEEDS TO BE IN \"SWITCH-STATEMENT

Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.