Algorithm explanation

Author: aliHafizji

Shunting Yard/README.markdown

@@ -0,0 +1,108 @@
+# Shunting Yard Algorithm
+
+Any mathematical expression that we write is expressed in a notation known as Infix Notation.
+
+For example:
+
+A + B * C
+
+In the above expression the operator is placed between operands hence the expression is said to be in Infix form.
+If you think about it any expression that you write on a piece of paper will always be in infix form. This is what we humans understand.
+
+Now, think about the way the above expression is evaluated, you would first multiply B and C then add the result to A. This is because multiplication has
+higher precedence than addition. We humans can easily understand the precedence of operators, but a machine needs to be given instructions about each operator. If you were to 
+write an algorithm than parsed and evaluated the infix notation you'll soon realize that it's a tedious process. You'd have to parse the expression
+multiple times to know what operation to perform first. As the number of operators increase so does the complexity.
+
+##  Postfix notations / Reverse Polish Notation 
+
+An expression when represented in postfix form will not have any brackets and neither will you have to worry about scanning for operator precedence. This makes it easy for the computer to evaluate
+expressions since the order in which the operator need to be applied is fixed.
+
+For example:
+
+**A B C * +**
+
+The above is the postfix representation of the example in the previous section. The operators come after the corresponding operands.
+
+### Evaluating a postfix expression
+
+A stack is used to evaluate a postfix expression. Here is the pseudocode:
+
+1. read postfix expression token by token
+2.   if the token is an operand, push it
+     into the stack
+3.   if the token is a binary operator,
+3.1    pop the two top most operands
+       from the stack
+3.2    apply the binary operator with the
+       two operands
+3.3    push the result into the stack
+4. finally, the value of the whole postfix
+   expression remains in the stack
+
+Using the above psuedocode the evaluation on the stack would be as follows:
+
+| Expression    | Stack   |
+| ------------- | --------|
+| A B C * +     |         |
+| B C * +       | A       |
+| C * +         | A, B    |
+| * +           | A, B, C |
+| +             | A, D    |
+|               | E       |
+
+Where **D = B * C** and **E = A + D.**
+
+As seen above a postfix operation is relatively easy to evaluate as the order in which the operators need to be applied is predecided.
+
+## Shunting yard algorithm
+
+The Shunting yard algorithm was invented by Edsger Dijkstra to convert an infix expression to postfix. Many calculators use this algorithm to convert the expression being entered to postfix form.
+
+Here is the psedocode of the algorithm:
+
+1. For all the input tokens
+    1. Read the next token
+    2. If token is an operator (x)
+        1. While there is an operator (y) at the top of the operators stack and either (x) is left-associative and its precedence is less or equal to that of (y), or (x) is right-associative and its precedence is less than (y)
+            1. Pop (y) from the stack
+            2. Add (y) output buffer
+        2. Push (x) on the stack
+    3. Else If token is left parenthesis, then push it on the stack
+    4. Else If token is a right parenthesis
+        1. Until the top token (from the stack) is left parenthesis, pop from the stack to the output buffer
+        2. Also pop the left parenthesis but don’t include it in the output buffer
+    7. Else add token to output buffer
+2. While there are still operator tokens in the stack, pop them to output
+
+### How does it work
+
+Let's take a small example and see how the psuedocode works. 
+
+**4 + 4 * 2 / ( 1 - 5 )**
+
+| Operator | Precedence   | Associativity   |
+| ---------| -------------| ----------------|
+| ^        | 10           | Right           |
+| *        | 5            | Left            |
+| /        | 5            | Left            |
+| +        | 0            | Left            |
+| -        | 0            | Left            |
+
+The above table describes the precedence and the associativity for each operator. The same values are used in the algorithm.
+
+| Token | Action                                      | Output            | Operator stack |
+|-------|---------------------------------------------|-------------------|----------------|
+| 3     | Add token to output                         | 4                 |                |
+| +     | Push token to stack                         | 4                 | +              |
+| 4     | Add token to output                         | 4 4               | +              |
+| *     | Push token to stack                         | 4 4               | * +            |
+| 2     | Add token to output                         | 4 4 2             | * +            |
+| /     | * Pop stack to output * Push token to stack | 4 4 2 *           | / +            |
+| (     | Push token to stack                         | 4 4 2 *           | ( / +          |
+| 1     | Add token to output                         | 4 4 2 * 1         | ( / +          |
+| -     | Push token to stack                         | 4 4 2 * 1         | - ( / +        |
+| 5     | Add token to output                         | 4 4 2 * 1 5       | - ( / +        |
+| )     | * Pop stack to output * Pop stack           | 4 4 2 * 1 5 -     | /  +           |
+| end   | Pop entire stack to output                  | 4 4 2 * 1 5 - / + |                |