The following program accepts an input expression that should be fully parenthesized but without left parentheses. It prints the equivalent infix expression with the left parentheses inserted.

using System;

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

            string input = args[0];

            foreach (string token in input.Split(" ".ToCharArray()))
            {
                switch (token)
                {
                    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 add the left parenthesis.
                                case "+":
                                case "-":
                                case "*":
                                case "/":
                                    val = "( " + values.Pop() + " " + op + " " + val + " )";
                                    break;
                                case "sqrt":
                                    val = "sqrt ( " + val + " )";
                                    break;
                            }

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

            Console.WriteLine(values.Pop()); // there should be one item on the values stack - the fully parenthesised expression
            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 ) ) )

1 + 2 * 1 + 3 ) ) ) --> ( 1 + ( 2 * ( 1 + 3 ) ) )

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