The following program converts an arithmetic expression from infix to postfix using a stack:

using System;

namespace ConsoleTest
{
    class Program
    {
        static void Main(string[] args)
        {
            Stack operators = new Stack();
            Stack values = new Stack(); // operands

            //string input = args[0];

            string input = "( ( 1 + sqrt ( 5.0 ) ) / 2.0 )"; 

            foreach (string token in input.Split(" ".ToCharArray()))
            {
                switch (token)
                {
                    case "(": // ignore left parentheses
                        break;
                    case "+":
                    case "-":
                    case "*":
                    case "/":
                    case "sqrt":
                        operators.Push(token);
                        break;
                    case ")":
                        {
                            // Pop an operator.
                            string op = operators.Pop();

                            // Pop the first operand.
                            string val = values.Pop();

                            switch (op)
                            {
                                // Pop the second operand and create a postfix expression.
                                case "+":
                                case "-":
                                case "*":
                                case "/":
                                    val = String.Format("( {0} {1} {2} )", values.Pop(), val, op);
                                    break;
                                case "sqrt":
                                    val = String.Format("( sqrt {0} )", val);
                                    break;
                            }

                            // Push onto the operand stack the result.
                            values.Push(val);
                        }
                        break;
                    default:
                        values.Push(token);
                        break;
                }
            }

            Console.WriteLine(values.Pop());
            Console.ReadKey();
        }

        class Stack where T : class
        {
            private Node first;
            private int N; // stack size

            public bool IsEmpty { get { return first == null; } }
            public int Size { get { return N; } }

            public void Push(T item)
            {
                Node oldFirst = first;
                first = new Node();
                first.Item = item;
                first.Next = oldFirst;

                ++N;
            }

            public T Pop()
            {
                T item = first.Item;
                first = first.Next;

                --N;

                return item;
            }

            private class Node
            {
                public T Item { get; set; }
                public Node Next { get; set; }

                public override string ToString() { return (Item == null ? "null" : Item.ToString()); }
            }
        }
    }
}

Sample output:

( ( 1 + 2 ) * ( ( 3 - 4 ) * ( 5 - 6 ) ) )  -->  ( ( 1 2 + ) ( ( 3 4 - ) ( 5 6 - ) * ) * )

( ( A * B ) + ( C / D ) ) --> ( ( A B * ) ( C D / ) + )

( ( A * ( B + C ) ) / D ) --> ( ( A ( B C + ) * ) D / )

( A * ( B + ( C / D ) ) ) --> ( A ( B ( C D / ) + ) * )

( ( 1 + sqrt ( 5.0 ) ) / 2.0 ) --> ( ( 1 ( sqrt 5.0 ) + ) 2.0 / )

You can find some mathematical background on infix and postfix expressions here