CareerCup

namespace InfixToPostFix
{
    class Program
    {
        public  static Hashtable precedence = new Hashtable();
        public static string sOutPutString;
         
        
        static void Main(string[] args)
        {
            string input = "a+b*c-d";

            precedence.Add("/", 4);
            precedence.Add("*", 3);
            precedence.Add("+", 2);
            precedence.Add("-", 1);

            foreach(DictionaryEntry Entry in precedence)
            {
              Console.WriteLine("{0} and {1}",Entry.Key, Entry.Value);
            }
           
            inFixtoPost(input);
            Console.Write(sOutPutString);
            Console.Read();
        }

        public static void inFixtoPost(string infix)
        {
            
            Stack s = new Stack();
            char[] cArrinput = infix.ToCharArray();
            Boolean bIsOperand;

           for (int i = 0; i < cArrinput.Length; i++)
           {
               char cTemp = cArrinput[i];
               bIsOperand = isOperand(cTemp);
              

               if (bIsOperand == true)
               {
                                     

                   if (s.Count == 0) // If stack is empty
                   {
                       s.Push(Convert.ToChar(cTemp));
                   }
                   else // If stack is not empty
                   {
                       int PeekPrecedence = Convert.ToInt32(precedence[s.Peek().ToString()]);
                       int iCurrentPrecedence = Convert.ToInt32(precedence[cTemp.ToString()]);
                       while (iCurrentPrecedence < PeekPrecedence && s.Count >0)
                       {
                           Char sTemp = Convert.ToChar(s.Pop());
                           sOutPutString = sOutPutString + sTemp;
                       }

                       s.Push(cTemp);                       
                   }
               }
               else // if it is not an operand               
               {
                   sOutPutString = sOutPutString + cTemp;
               }

               if (i == cArrinput.Length - 1)
               {
                   while (s.Count > 0)
                   {
                       sOutPutString = sOutPutString + Convert.ToChar(s.Pop());
                   }
               }
           }          
         
           
        }

        public static Boolean isOperand(char cOperandCheck)
        {
            if (cOperandCheck == '+' || cOperandCheck == '/' || cOperandCheck == '-' || cOperandCheck == '*')
            {
                return true;
            }
            else { return false; }
        }
    }
}

<pre lang="" line="1" title="CodeMonkey35160" class="run-this">// supose an expression e can be:
// e = variable
// |= constant
// |= e comparator e

InfixExpression PostInConvert (PostfixExpression pe) {
if (isConstant(pe) || isVariable(pe)) return pe;

InfixExpression ie = new InfixExpression();
ie.comparator = pe.comparator;
ie.left = PostInConvert(pe.first);
ie.right = PostInConvert(pe.second);
return ie;
}</pre><pre title="CodeMonkey35160" input="yes">
</pre>

<pre lang="" line="1" title="CodeMonkey1135" class="run-this">// here is the parsing code from String to PostfixExpression
// well.... it is just a pseudo code

PostfixExpression parser (String inputs) {
Stack<String> stack_main = new Stack();
Stack<Expression> stack_keep = new Stack();

while (inputs.hasNextToken()) {
stack_main.push(inputs.nextToken());
}

while (stack_main.empty() == false) {
if (isComparator(stack_main.peek())) {
PostfixExpression newPE =
new PostfixExpression(stack_main.pop(),
stack_keep.pop(),
stack_keep.pop());
stack_keep.push(newPE);
}
else {
stack_keep.push(newPostfixExpression(stack_main.pop()));
}
}

return stack_keep.pop();
}</pre><pre title="CodeMonkey1135" input="yes">
</pre>

using 2 stacks we can implement the postfix expre to infix expr