中缀转后缀表达式

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

namespace CSTEST
{

    class Test
    {
        enum ProrLevel
        {
            None = -1,
            AddOrSub = 1,//+ -
            Mul = 2,//*/
            FirstParent = 100,//(
            SecondParent = 4,//)
        }
        private char[] operateStr = { '+', '-', '*', '/', '(', ')', };
        private int[] dataArr = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };

        static void Main(string[] args)
        {
            Test myTest = new Test();
            int operateLength = myTest.operateStr.Length;

            string addString = "9+*2/1";

            List<string> midList = new List<string>();
            List<string> behindList = new List<string>();
            Stack<string> operStack = new Stack<string>();

            myTest.Spilt_operate_array(addString, ref midList);

            for (int i = 0; i < midList.Count; ++i)
            {
                Console.Write(midList[i] + " ");
            }
            myTest.PushListToStack(ref midList, ref behindList, ref operStack);

            Console.WriteLine();
            for (int i = 0; i < behindList.Count; ++i)
            {
                Console.Write(behindList[i] + " ");
            }
        }

        //对()括号的处理
        private void SetParent(ref Stack<string> stack, ref List<string> behidList)
        {
            string popStr = stack.Peek();
            while (!string.Equals(popStr, "("))
            {
                behidList.Add(popStr);
                stack.Pop();
                popStr = stack.Peek();
            }
            stack.Pop();
        }

        //对整个list栈操作
        private void PushListToStack(ref List<string> midList, ref List<string> behindList, ref Stack<string> operFunStack)
        {
            for (int i = 0; i < midList.Count; ++i)
            {
                char tempMid = midList[i][0];
                if (Is_spilt_flag(tempMid, operateStr))
                {
                    PushOperToStack(midList[i], ref operFunStack, ref behindList);
                }
                else
                {
                    behindList.Add(midList[i]);
                }
            }
            ClearOperStack(ref operFunStack,ref behindList);
        }
        //如果最后stack内还有数据，则直接压入list
        private void ClearOperStack(ref Stack<string> stack, ref List<string> behindList)
        {
            if (stack == null || stack.Count == 0) return;
            while (stack.Count != 0)
            {
                behindList.Add(stack.Peek());
                stack.Pop();
            }
        }
        //如果优先级比较大
        private void HighPrior(string pushStr, string peekStr, ref Stack<string> stack, ref  List<string> behidList)
        {
            do
            {
                if (string.Equals(pushStr, ")"))
                {
                    SetParent(ref stack, ref behidList);
                    break;
                }
                else
                {
                    behidList.Add(peekStr);
                    stack.Pop();
                    if (stack.Count > 0)
                    {
                        peekStr = stack.Peek();
                    }
                    else
                    {
                        break;
                    }
                }
            } while (IsPrior(pushStr, peekStr) && stack.Count > 0);
            if (!string.Equals(pushStr, ")"))
            {
                stack.Push(pushStr);
            }
        }
        //如果优先级比较小
        private void LowPrior(string pushStr, ref Stack<string> stack)
        {
            stack.Push(pushStr);
        }
        //运算符的出栈入栈
        private void PushOperToStack(string pushStr, ref Stack<string> stack, ref  List<string> behidList)
        {
            if (stack.Count == 0)
            {
                stack.Push(pushStr);
            }
            else
            {
                string peekStr = stack.Peek();
                if (IsPrior( peekStr,pushStr))
                {
                    HighPrior(pushStr, peekStr, ref stack, ref behidList);
                }
                else
                {
                    LowPrior(pushStr, ref stack);
                }
            }
        }

        //赋与运算符数值
        private void TransToInt(char elemet, out ProrLevel level)
        {
            switch (elemet)
            {
                case '+':
                case '-':
                    level = ProrLevel.AddOrSub;
                    break;
                case '*':
                case '/':
                    level = ProrLevel.Mul;
                    break;
                case '(':
                    level = ProrLevel.FirstParent;
                    break;
                case ')':
                    level = ProrLevel.SecondParent;
                    break;
                default:
                    level = ProrLevel.None;
                    Console.WriteLine("error!!没有此运算符号！");
                    break;
            }
        }
        //+-*/运算符优先级的判断;优先级相同的话，也为false，弹出stack
        //如果为（则为false
        private bool IsPrior(string inStack, string pushToStack)
        {
            ProrLevel inStackLevel;
            TransToInt(char.Parse(inStack), out inStackLevel);
            //if (inStackLevel==ProrLevel.FirstParent)
            //{
            //    return false;
            //}
            ProrLevel pushToStackLevel;
            TransToInt(char.Parse(pushToStack), out pushToStackLevel);
            if ((int)pushToStackLevel >= (int)inStackLevel)
            {
                return true;
            }
            return false;
        }

        #region 对表达式进行拆分
        //对表达式进行拆分
        private void Spilt_operate_array(string opArr, ref List<string> midArrlist)
        {
            if (string.IsNullOrEmpty(opArr))
            {
                Console.WriteLine("空，不是表达式！！");
            }
            char oldChar = opArr[0];
            string tempData = oldChar.ToString();
            string tempOper = string.Empty;
            if (Is_spilt_flag(oldChar, operateStr))
            {
                Console.WriteLine("第一个字符出错，不是表达式！！");
            }
            oldChar = opArr[opArr.Length - 1];
            if (Is_spilt_flag(oldChar, operateStr))
            {
                Console.WriteLine("最后一字符出错，不是数字！！");
            }
            for (int i = 1; i < opArr.Length; ++i)
            {
                bool bNumber = Is_number(opArr[i], dataArr);

                if (bNumber)
                {
                    tempData += opArr[i].ToString();
                    if (i == opArr.Length - 1)
                    {
                        midArrlist.Add(tempData);
                    }
                    tempOper = string.Empty;
                }
                else
                {
                    if (!string.IsNullOrEmpty(tempData))
                    {
                        midArrlist.Add(tempData);
                        tempData = string.Empty;
                    }
                    IsTwoOper(tempOper,opArr[i].ToString());
                    tempOper = opArr[i].ToString();
                    bool bOper = Is_spilt_flag(opArr[i], operateStr);
                    if (bOper)//运算符，进行拆分
                    {
                        midArrlist.Add(opArr[i].ToString());
                    }
                    else
                    {
                        Console.WriteLine("不是数字 不是运算符号 不是表达式！！");
                        break;
                    }
                }
            }
            
        }
        //两个非括号的运算符在一起，则不是表达式
        private void IsTwoOper(string tempStr,string operString)
        {
            if (!string.IsNullOrEmpty(tempStr))
            {
                if (!IsKuoHao(tempStr) && !IsKuoHao(operString))
                {
                    Console.WriteLine("两个运算符在一起了！！");
                    return;
                }
            }
        }
        private bool IsKuoHao(string testStr)
        {
            if (string.Equals(testStr,"(")||string.Equals(testStr,")"))
            {
                return true;
            }
            return false;
        }
        #endregion

        #region 判断是数字还是运算符
        //检测一个字符是否是+-*、（），是的话进行拆分到list里
        private bool Is_spilt_flag(char spiltChar, char[] opArr)
        {
            for (int i = 0; i < opArr.Length; ++i)
            {
                if (Char.Equals(spiltChar, opArr[i]))
                {
                    return true;
                }
            }
            return false;
        }
        //是否是数字0-9
        private bool Is_number(char element, int[] elemArray)
        {
            int data = element - 48;

            for (int i = 0; i < elemArray.Length; ++i)
            {
                if (data == elemArray[i])
                {
                    return true;
                }
            }
            return false;
        }
        #endregion
    }

}