Question

2 - 35 pts) You are given the code (including the main function) for evaluating an expression in post-fix format using Stack. Your task is to modify the code in the main function to input an expression in pre-fix format, reverse it (as discussed in class) and then evaluate the value of the reversed expression (scanned from left to right) using Stack. You test your code with an expression string in pre-fix format that comprises of all the four operators (at least once) in a randomly chosen order with randomly chosen values in the range1 to 9. For example, a sample expression string (pre-fix notation) could be input as+,1,5,2,3, 4,8 for the expression (infix-notation) 5/2 3+4-8. You need to submit the following for this question: (1) The complete code (including the modification to evaluate an expression in pre-fix format) of the Stack class, Node class and the main function. (2) Screenshot of the execution of the code for a sample pre-fix expression, like the one given above.

#include <iostream>
#include <string>
#include <cstring>
using namespace std;

class Node{
  
   private:
       int data;
       Node* nextNodePtr;
      
   public:
       Node(){}
      
       void setData(int d){
           data = d;
       }
      
       int getData(){
           return data;
       }
      
       void setNextNodePtr(Node* nodePtr){
               nextNodePtr = nodePtr;
       }  
      
       Node* getNextNodePtr(){
           return nextNodePtr;
       }
          
};

class Stack{

   private:
       Node *headPtr;
  
   public:
       Stack(){
           headPtr = new Node();
           headPtr->setNextNodePtr(0);
       }
  
       Node* getHeadPtr(){
           return headPtr;
       }
  
       bool isEmpty(){
          
           if (headPtr->getNextNodePtr() == 0)
               return true;
          
           return false;
       }
      
      
       void push(int data){
          
           Node* currentNodePtr = headPtr->getNextNodePtr();
           Node* prevNodePtr = headPtr;
          
           while (currentNodePtr != 0){
               prevNodePtr = currentNodePtr;
               currentNodePtr = currentNodePtr->getNextNodePtr();
           }
          
           Node* newNodePtr = new Node();
           newNodePtr->setData(data);
           newNodePtr->setNextNodePtr(0);
           prevNodePtr->setNextNodePtr(newNodePtr);                      
          
       }
          
      
       int peek(){
          
           Node* currentNodePtr = headPtr->getNextNodePtr();
           Node* prevNodePtr = headPtr;
          
           if (currentNodePtr == 0){
               return -1000000; // stack is empty
           }
          
           while (currentNodePtr->getNextNodePtr() != 0)
               currentNodePtr = currentNodePtr->getNextNodePtr();
          
           return currentNodePtr->getData();
          
       }

          
      
       int pop(){  
          
           Node* currentNodePtr = headPtr->getNextNodePtr();
           Node* prevNodePtr = headPtr;
          
           if (currentNodePtr == 0){
               return -1000000; // stack is empty
           }
          
           while (currentNodePtr->getNextNodePtr() != 0){
              
               prevNodePtr = currentNodePtr;
               currentNodePtr = currentNodePtr->getNextNodePtr();              

           }
          
           prevNodePtr->setNextNodePtr(0);
           return currentNodePtr->getData();
      
       }
      

      
};

int main(){

   Stack stack;

   string expression;
  
   cout << "Enter the expression to evaluate: ";
   getline(cin, expression);
  
   char* expressionArray = new char[expression.length()+1];
   strcpy(expressionArray, expression.c_str());
  
   char* cptr = strtok(expressionArray, ", ");
  
   while (cptr != 0){
      
       string token(cptr);
      
       bool isOperator = false;
      
       if ( (token.compare("*") == 0) || (token.compare("/") == 0) || (token.compare("+") == 0) || (token.compare("-") == 0) )
           isOperator = true;
      
       if (!isOperator){
           int val = stoi(token);
           stack.push(val);
       }
      
      
       if (isOperator){
          
           int rightOperand = stack.pop();
           int leftOperand = stack.pop();
          
           if (token.compare("*") == 0){
               int result = leftOperand * rightOperand;
               cout << "intermediate result: " << leftOperand << "*" << rightOperand << "=" << result << endl;
               stack.push(result);
           }          
           else if (token.compare("/") == 0){
               int result = leftOperand / rightOperand;
               cout << "intermediate result: " << leftOperand << "/" << rightOperand << "=" << result << endl;
               stack.push(result);
           }
           else if (token.compare("+") == 0){
               int result = leftOperand + rightOperand;
               cout << "intermediate result: " << leftOperand << "+" << rightOperand << "=" << result << endl;
               stack.push(result);
           }
           else if (token.compare("-") == 0){
               int result = leftOperand - rightOperand;
               cout << "intermediate result: " << leftOperand << "-" << rightOperand << "=" << result << endl;
               stack.push(result);
           }
          
       }
      
      
       cptr = strtok(NULL, ", ");
   }
  
   cout << "final result: " << stack.pop() << endl;
  
  
return 0;
}

Answer 1

Note: Kindly post remaining questions separately Q1) Program import java.util.Scanner; class linked list node head, tail; class node int element node next; node (int elem) element-elem; next null; void deleteElement (int deleteData) node t head, p nulli if (t - null &&t.elementdeleteData) head t.nexti deleteElement (deleteData) i return while (t null && t.element deleteData) p- ti t - t.next if (tnull) return; p.next - t.next; deleteElement (deleteData)

public void Insert (int new element) node newNodenew node (new element) ; if (newNodenuli) else return neWNode. next null; if (head null) head newNodei tail-newNode else tail.next newNode tail newNode; public void printElements) node tempnodeheadi while (tempnodenull) System.out.print (tempnode.element+" ") tempnodetempnode,next; System.out.print ("י') ; public static void main(String [l args) linked list llist new linked list;

[10:00 AM, 3/7/2019] Narasimha: Editable code:

Q1)

Program

import java.util.Scanner;

class linked_list

{

node head,tail;

class node

{

int element;

node next;

node(int elem)

{

element = elem;

next = null;

}

}

void deleteElement(int deleteData)

{

node t= head, p= null;

if (t != null && t.element == deleteData)

{

head = t.next;

deleteElement(deleteData);

return;

}

while (t != null && t.element != deleteData)

{

p= t;

t = t.next;

}

if (t == null) return;

p.next = t.next;

deleteElement(deleteData);

}

public void Insert(int new_element)

{

node newNode = new node(new_element);

if (newNode == null)

return;

else

{

newNode.next = null;

if (head == null)

{

head = newNode;

tail = newNode;

}

else

{

tail.next = newNode;

tail = newNode;

}

}

}

public void printElements()

{

node tempnode = head;

while (tempnode != null)

{

System.out.print(tempnode.element+" ");

tempnode = tempnode.next;

}

System.out.print("");

}

public static void main(String[] args)

{

linked_list llist = new linked_list();

Scanner sc=new Scanner(System.in);

System.out.print("Enter the number of elements you want to insert : ");

int N;

N = sc.nextInt();

for(int i = 0 ; i < N; i++){

int M;

System.out.print("Enter element # " + i + " : ");

M = sc.nextInt();

llist.Insert(M);

}

System.out.print("\n Content of list ( before delete )");

llist.printElements();

System.out.print("\nEnter the number you want to delete : ");

int D;

D = sc.nextInt();

llist.deleteElement(D);

System.out.print("\n Content of list ( after delete ) :");

llist.printElements();

}

}