Esempio n. 1
0
        private static string[] InfixToRPN(string[] tokens)
        {
            Stack <char>   charStack = new Stack <char>();
            Stack <string> source    = new Stack <string>();

            foreach (string token in tokens)
            {
                if (ExpressionEvaluator.IsCommand(token))
                {
                    char character = token[0];
                    switch (character)
                    {
                    case '(':
                        charStack.Push(character);
                        continue;

                    case ')':
                        while (charStack.LongCount <char>() > 0L && (int)charStack.Peek() != 40)
                        {
                            source.Push(charStack.Pop().ToString());
                        }
                        if (charStack.LongCount <char>() > 0L)
                        {
                            int num = (int)charStack.Pop();
                            continue;
                        }
                        continue;

                    default:
                        ExpressionEvaluator.Operator newOperator = ExpressionEvaluator.CharToOperator(character);
                        while (ExpressionEvaluator.NeedToPop(charStack, newOperator))
                        {
                            source.Push(charStack.Pop().ToString());
                        }
                        charStack.Push(character);
                        continue;
                    }
                }
                else
                {
                    source.Push(token);
                }
            }
            while (charStack.LongCount <char>() > 0L)
            {
                source.Push(charStack.Pop().ToString());
            }
            return(source.Reverse <string>().ToArray <string>());
        }
        private static string[] InfixToRPN(string[] tokens)
        {
            Stack <char>   stack  = new Stack <char>();
            Stack <string> stack2 = new Stack <string>();

            for (int i = 0; i < tokens.Length; i++)
            {
                string text = tokens[i];
                if (ExpressionEvaluator.IsCommand(text))
                {
                    char c = text[0];
                    if (c == '(')
                    {
                        stack.Push(c);
                    }
                    else if (c == ')')
                    {
                        while (stack.LongCount <char>() > 0L && stack.Peek() != '(')
                        {
                            stack2.Push(stack.Pop().ToString());
                        }
                        if (stack.LongCount <char>() > 0L)
                        {
                            stack.Pop();
                        }
                    }
                    else
                    {
                        ExpressionEvaluator.Operator newOperator = ExpressionEvaluator.CharToOperator(c);
                        while (ExpressionEvaluator.NeedToPop(stack, newOperator))
                        {
                            stack2.Push(stack.Pop().ToString());
                        }
                        stack.Push(c);
                    }
                }
                else
                {
                    stack2.Push(text);
                }
            }
            while (stack.LongCount <char>() > 0L)
            {
                stack2.Push(stack.Pop().ToString());
            }
            return(stack2.Reverse <string>().ToArray <string>());
        }
Esempio n. 3
0
        private static string[] InfixToRPN(string[] tokens)
        {
            Stack <char>   stack = new Stack <char>();
            Queue <string> queue = new Queue <string>();

            for (int i = 0; i < tokens.Length; i++)
            {
                string text = tokens[i];
                if (ExpressionEvaluator.IsCommand(text))
                {
                    char c = text[0];
                    if (c == '(')
                    {
                        stack.Push(c);
                    }
                    else if (c == ')')
                    {
                        while (stack.Count > 0 && stack.Peek() != '(')
                        {
                            queue.Enqueue(stack.Pop().ToString());
                        }
                        if (stack.Count > 0)
                        {
                            stack.Pop();
                        }
                    }
                    else
                    {
                        ExpressionEvaluator.Operator newOperator = ExpressionEvaluator.CharToOperator(c);
                        while (ExpressionEvaluator.NeedToPop(stack, newOperator))
                        {
                            queue.Enqueue(stack.Pop().ToString());
                        }
                        stack.Push(c);
                    }
                }
                else
                {
                    queue.Enqueue(text);
                }
            }
            while (stack.Count > 0)
            {
                queue.Enqueue(stack.Pop().ToString());
            }
            return(queue.ToArray());
        }