Any Suggestions?

Question

I know you have seen tons of these questions from students, but mine is a bit different. I am not asking how to do the convertions, I am asking how to remove parens. I have partically done some of the paren removal, but as you can see from my output below, I still have a spare in locations that really don't need them. I am wondering if I need to do a second run through the expression and "strip" parens or not.
Any ideas, suggestions or hints would be greatly appreciated.
Infix and Postfix Expressions
Author: C. K. Bales
Copyright 2002
Starting Infix to Postfix Expressions:
Infix Expression: (A+C)*D
Postfix Expression: AC+D*
Infix Expression: A+C*D
Postfix Expression: ACD*+
Infix Expression: Z+D-F*G
Postfix Expression: ZD+FG*-
Infix Expression: (Z+D-F)*G
Postfix Expression: ZD+F-G*
Infix Expression: A^3*B^2*C^1
Postfix Expression: A3^B2^*C1^*
Infix Expression: A-B^C
Postfix Expression: ABC^-
Starting Postfix to Infix Expressions:
Postfix Expression: XYZ+*
Infix Expression: X*Y+Z
Postfix Expression: KJ*L/
Infix Expression: (K*J)/L
Postfix Expression: ACD*+
Infix Expression: A+C*D
Postfix Expression: ZD+F-G*
Infix Expression: ((Z+D)-F)*G
End of Expressions in File.
Thank you for using our software.
The two that I would like to strip the parens from are (K*J)/L and ((Z+D)-F)*G.
They should read K*J/L and (Z+D-F)*G.
The code that currently handles removing the parens is:
if (!stack.isEmpty() && isOperand(temp.toString())) {
x = (String)stack.pop();
y = (String)stack.pop();
together = "(" + y + postfix + x + ")";
infix += together;
infixExpr = infix;
together = "";
infix = "";
} else {
x = (String)stack.pop();
y = (String)stack.pop();
together = y + postfix + x;
infix += together;
infixExpr = infix;
together = "";
infix = "";
} //end if
stack.push(infixExpr);
Should I run a deeper check than that? I really don't want to make it more complicated than it needs to be...like I said, any ideas, suggestions, hints would be greatly appreciated...thanks!
CK

Answer 1

Let's see if I get this right. I am currently taking the Data Structures class and Big(O) and I have not been getting along terribly well. I am serverly dyslexic and the Data Structures text book uses very long and complicated string computations to result in the Big(O) notation. I have re-read those chapters several times to try to get it down for the final.
Ok, ACIDS is the mechinism used to test which ADT is best to use:
Add
Change
Inspect
Delete
Sort
Arrays -
They have a fixed size and give the programmer the advantage of the [] sub-brackets to access data items within the array.
To insert it is n-1 moves
To delete it is n-1 moves
To insert in order it is n-1 moves
And you can go straight to any point in the array.
Current sort algorithms work with an array
Linked Lists -
Insert at front of list is n
Delete from front of list is n
Dynamic size
Add in order is n links
Delete a specific link is n links
Current sort algorithms don't work with a Linked List
Big(O) of a Linked List is on most cases n
Big(O) of an Array on most cases is n^2.
When is it best to use one over the other?
If there will not be a lot of changes done to the data, and you need instant access to each element of data, use an array.
If there will be a great many changes done to the data, and instant access isn't overtly necessary, use a Linked List.
Which uses less memory as they "increase". To increase an Array you must create a new array and copy the old one into it. Such things as ArrayLists automatically double the size of the array as you add new elements to it. Both use a lot of overhead in maintaining a contiguious segment of memory to hold the information within them.
A Linked List doesn't need contiguious memory, and only increases by one each time a link is added, therefore it doesn't use a lot of memory.
Both can be fast for small amounts of data, but over time, a Linked List will be faster than an array with extremely large amounts of data.
Though I may be wrong on the Big(O) part, I have been reading my homework and have gotten full points on my other three assignments in this class so far.
<g>
Thanks, that was fun!
CK