逆波兰式

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace EvaluateReversePolishNotation
{
    class Program
    {
        /// <summary>
        /// 逆波兰式：  
        /// ["2", "1", "+", "3", "*"] -> ((2 + 1) * 3) -> 9
        /// ["4", "13", "5", "/", "+"] -> (4 + (13 / 5)) -> 6
        /// 这一题就是写程序计算逆波兰式的结果，遍历表达式，碰到操作数入栈，碰到操作符就从栈顶取出两个操作数，
        /// 再将计算后的结果入栈，最后栈中剩余的唯一操作数就是计算结果。  
        /// </summary>
        /// <param name="args"></param>

        public class Node
        {
            public int val;
            public Node next;
            public Node(int x)
            {
                val = x;
            }
        }

        public class Stack
        {
            public Node top;
            public void valIn(Node n)
            {
                if (n != null)
                {
                    Node temp = top;
                    top = n;
                    top.next = temp;
                }
                else
                {
                    top = n;
                    top.next = null;
                }
            }

            public Node valOut()
            {
                if (top == null)
                {
                    return null;
                }
                else
                {
                    Node temp = new Node(top.val);
                    top = top.next;
                    return temp;
                }
            }
        }
        public static int calculte(string a, Node x, Node y, ref int result)
        {
            switch (a)
            {
                case "+":
                    result = x.val + y.val;
                    return result;
                case "-":
                    result = x.val - y.val;
                    return result;
                case "*":
                    result = x.val * y.val;
                    return result;
                case "/":
                    result = x.val / y.val;
                    return result;
                default:
                    return 0;
            }
        }
        static void Main(string[] args)
        {
            string[] list = { "4", "13", "5", "/", "+" };
            Stack sk = new Stack();
            Node inn = null;
            Node outn_first = null;
            Node outn_second = null;
            int num = 0;

            foreach (var a in list)
            {
                if (int.TryParse(a, out num))
                {
                    inn = new Node(num);
                    sk.valIn(inn);
                    sk.top = inn;
                }
                else
                {
                    if (sk.top != null)
                    {
                        int result = 0;
                        outn_first = sk.valOut();
                        outn_second = sk.valOut();
                        result = calculte(a, outn_second, outn_first, ref result);
                        sk.valIn(new Node(result));
                    }
                }
            }
            Console.WriteLine(sk.top.val);
            Console.ReadKey();
        }
    }
}