read an expression and solve it...

[Justin Fox]

ok my program is supposed to read an expression, like so...

(64%(9/(6-3)))

but im having some problems...

    
import java.util.Scanner;
 

public class StackImple
{
public static void main (String[]args)
{
 
Scanner scan = new Scanner(System.in);
 
Stack NumStack;
charStack OpStack;
String answer;
char dop;
int count1 = 0;
int count2 = 0;
 
boolean Valid;
 
//*************************************************
// starts the do loop of asking the question, and
// evaluating the expressiong given
//*************************************************
 

do
{
 
Valid = false;
 
System.out.println("Enter an Expression: ");
answer = scan.nextLine();
 
char [] charArray = new char [answer.length()];
NumStack = new Stack(answer.length());
OpStack = new charStack(answer.length());
 

 
for (int i = 0; i<charArray.length; i ++)
{
charArray[i] = answer.charAt(i);

}
 

 

for(int i = 0; i< charArray.length; i++)
{
char value = charArray[i];
 
//************************************************
// here I switched all the possible chars and
// numbers and then pushed them to the 
// corresponding Stack.
//************************************************
 

switch (value)
{
case '2':

NumStack.push(2);
break;
 
case '1':

NumStack.push(1);
break;
 
case '3':

NumStack.push(3);
break;

case '4':

NumStack.push(4);
break;
 
case '5':
 
NumStack.push(5);
break;
 
case '6':

NumStack.push(6);
break;

case '7':
 
NumStack.push(7);
break;
 
case '8':
 
NumStack.push(8);
break;
 
case '9':
 
NumStack.push(9);
break;
 
case '+':
OpStack.push('+');
break;
 
case '-':

OpStack.push('-');
break;
 
case '*':

OpStack.push('*');
break;

case '/':

OpStack.push('/');
break;
 
case '%':
 
OpStack.push('%');
break;
 
case '^':
 
OpStack.push('^');
break;
 
case '(':
count1++;
break;
 
case')':
count2++;
int one = NumStack.pop();
int two = NumStack.pop();
char oper = OpStack.pop();
 

//***************************************************
// after i pushed the char/numbers I used the
  // algorithm given to find out the value of the first
// two numbers in the number stack.
//***************************************************
 

switch(oper)
{
case '+':
 
int result = (two + one);
NumStack.push(result); 
break;
 
case '-':
 
int result2 = (two - one);
NumStack.push(result2);
break;
 
case '*':
 
int result3 = (two * one);
NumStack.push(result3);
break;
 
case '/':
 
if(one != 0)
{
int result4 = (two / one);
NumStack.push(result4);
}
else
{
System.out.println("\n\n");
System.out.println("can't divide by zero!");
}
break;
 
case '%':
 
int result5 = (two % one);
NumStack.push(result5);
break;
 
case '^':
 
int result6 = (Exp.recursiveExponent(two,two,one));
NumStack.push(result6);
break;
}
}
}
 

//*****************************************************
// after i evaluate the expression, I then test to see if
// the algorithm worked properly after using the user's 
        // input.
//*****************************************************
 

if(!OpStack.isNotEmpty() && !(NumStack.Size() > 1) )
{
System.out.println("\t\t\t---------------");
System.out.println("\t\t\tNumber Stack");
System.out.println("\t\t\t---------------");
 
NumStack.dump();
 
System.out.println("\t\t\t---------------");
System.out.println("\t\t\tOperator Stack");
System.out.println("\t\t\t---------------");
 
OpStack.dump();
 
System.out.println("\n\n");
System.out.print("result: " + NumStack.pop()+"\n\n\n");

}
 
else if ( OpStack.isNotEmpty())
System.out.println("Missing an Operand!");
 

else if( NumStack.Size() > 0)
System.out.println("Missing an Operator!");
 

System.out.println(count1);
System.out.println(count2);
count1= 0;
count2 = 0;
 
}while(!answer.equalsIgnoreCase("exit"));
 

 
}
}
 

here is my stack class...

    
public class Stack
{
public int count = 0, size = 0, top = -1;
public String result;
public int [] array;
public enum errormsg{UNDERFLOW, OVERFLOW};
int front = 0;
 
public Stack(int number)
{
array = new int [number];
}
 
public void push(int num)
{
if(isNotFull())
{
top++;
array[top] = num;
}
else
{
stackError(errormsg.OVERFLOW);
 
}
}
 
public int pop()
{
    if( isNotEmpty() )
        return array[top--];
    else
    {   stackError( errormsg.UNDERFLOW );  }
return 0;
  }
 
public int peek()
{
if(isNotEmpty())
return array[top];
else 
stackError(errormsg.UNDERFLOW);
return 0;
}
 
public boolean isNotFull()
{
return top<array.length-1;
}
 
public boolean isNotEmpty()
{
return top >= 0;
}
 
public void dump()
{
 
System.out.print("\t\t\t top: " + top + " Contents: " );
 front = top;
 
while(front>=0)
System.out.print(array[front--] + " ");
 
System.out.println();
 
}
 
public int Size()
{
return top;
}
 
public void stackError(errormsg msg)
{
 switch (msg)
{
case UNDERFLOW:
System.out.println("stack is empty!");
break;
case OVERFLOW:
System.out.println("stack is full!");
break;
}
}
}
 

and i have one for a char stack too.... same .Size() method...

but say i input (9/(56-3))

the number stack would hold 9,56,3

the Operator stack would hold /,-

but when it hits that first ')'

it pops, the first two numbers, and the first operator and does
the indicated operation, which is.

56-3 = 53, then pushes 53 onto the number stack... so now the stack hold

numberstack = 9,53

Operator stack = /

but my output for some reason, is

numstack = 9,1

and operator is empty...


im lost now, i tried to fix it, but yeah....

please help..

justin

[Justin Fox]

lol nvm, the prof gave us that, and didn't put a space between the 5 and 6...

so its supposed to be (9/(5 6-3)).

it's supposed to test to see if our program catches the missing operator...

i have my if statement, but for somreason my .Size() method doesn't work,

i return top, which at the end of the evaluation is 1 in the num stack,

so it should print "Missing operator!"

but it doesn't..

im not sure but i think im supposed to use this

like

    
public static int Size()
{
return top;
}

see that should work, but for some odd reason it doesn't..

help,
Justin

[Campbell Ritchie]

A bit difficult to see exactly what is going on because you don't provide the charStack class (which by the way ought to be CharStack).
Were you really told to use an array and make a Stack of restricted size?

Your getSize() method is returning the top item because that is what you have told it to do.

CR

[Justin Fox]

i know, and i have

if (NumStack.Size() > 1)
System.out.println("Missing Operator!");

and when i do...

(9/(5 6 - 3))

at the end of the evaluation of the expression

numstack contains... 9 and 1
and the OpStack contains nothing.

so it would be like this
____ ____
| 9 || 1 | <---- the contents of NumStack
0 1 <---- the Index of the NumStack

so if i said..

public int Size()
{
return top+1;
}

so when it comes to the end of the program and tests the stacks...

it should catch that NumStack.size() is infact greater than 1, and print

out missing operator, but doesn't...

thanks,
Justin

[Campbell Ritchie]

Well, it is still not a getSize() method if it prints anything out. I still can't see how your app is supposed to work. Where is the CharStack class?

[Campbell Ritchie]

I have had a look at your stacks.
You can get a String to an array of chars much more easily than you have done. Look through the String class API.
Your switch method to fill the stacks is unnecessary. All you have to do is use the methods in the Character class to find out whether your char represents a digit, and use that to decide which Stack to put it on. You can probably also find out whether a particular char is whitespace and "lose" it.

But I think your stack will only work for single digits. If you put 9 56 3 in, you won't get 3 56 9 back. You will get 3 6 5 9. So you put three numbers in and get four back. It will make all your arithmetic wrong, and will also result in your still having items in your stack when you have finished.

Think what you can do with your char[] array if you find two consecutive digits.

You are going to have to take a different approach. Get your number and operator stacks, and test them. Give them push peek and pop methods, and getCount isFull and isEmpty methods. Give each of them a toString() method which prints out their details, and print method, which can be very simple:

public void print()
    {
        System.out.println(this);
    }

Give each of them main methods, and push and peek and pop numbers/operators. Go through them until you are happy they are working. Then get back to the class you are working on.