Installation and Configuration
Programming Methodology
Video Tutorials

Evaluating Reverse Polish Notation Using Queue and Stack in C#

n this exercise, you will create a program that reads a Reverse Polish Notation (RPN) expression from a text file. RPN is a mathematical notation in which every operator follows all of its operands, removing the need for parentheses.

The program will first store each item from the RPN expression into a queue. Once all items are stored, they will be transferred from the queue to a stack using the Queue and Stack classes provided in C#. The stack will then be used to evaluate the RPN expression step by step, performing arithmetic operations as required.

By completing this exercise, you will gain experience in handling both queue and stack data structures, working with file input, and processing mathematical expressions in a structured way. This type of evaluation is widely used in compilers and calculators.



Group

Dynamic Memory Management in C#

Objective

1. Read an RPN expression from a text file.
2. Store each item in a queue.
3. Transfer elements from the queue to a stack.
4. Process the stack to compute the result of the RPN expression.
5. Display the final result on the console.

Create a program that reads a Reverse Polish Notation expression from a text file, for example: 

3 4 6 5 - + * 6 +

(Result 21)


Each item will be stored in a queue. Once the queue has all the items stored, you will need to transfer them from the queue to a stack using the Queue and Stack classes provided in C#.

Finally, you will operate with the stack to get the correct result of the RPN expression and show it on the console.

Example C# Exercise

 Copy C# Code 
using System;
using System.Collections.Generic;
using System.IO;

class ReversePolishNotation
{
    static void Main()
    {
        // Define the file path where the RPN expression is stored
        string filePath = "rpn_expression.txt";

        // Read the expression from the file
        string expression = File.ReadAllText(filePath).Trim();

        // Split the expression into individual tokens (numbers and operators)
        string[] tokens = expression.Split(' ');

        // Create a queue to store the tokens
        Queue queue = new Queue();

        // Enqueue each token into the queue
        foreach (string token in tokens)
        {
            queue.Enqueue(token);
        }

        // Create a stack to process the RPN expression
        Stack stack = new Stack();

        // Process the queue and evaluate the RPN expression
        while (queue.Count > 0)
        {
            string currentToken = queue.Dequeue();

            // Check if the token is a number
            if (int.TryParse(currentToken, out int number))
            {
                // Push the number onto the stack
                stack.Push(number);
            }
            else
            {
                // If the token is an operator, pop two values from the stack
                int b = stack.Pop();
                int a = stack.Pop();

                // Perform the corresponding operation
                int result = currentToken switch
                {
                    "+" => a + b,
                    "-" => a - b,
                    "*" => a * b,
                    "/" => a / b,
                    _ => throw new InvalidOperationException("Invalid operator encountered.")
                };

                // Push the result back onto the stack
                stack.Push(result);
            }
        }

        // The final result will be the only value left in the stack
        Console.WriteLine($"Result: {stack.Pop()}");
    }
}

 Output

Result: 21

Share this C# Exercise

More C# Practice Exercises of Dynamic Memory Management in C#

Explore our set of C# Practice Exercises! Specifically designed for beginners, these exercises will help you develop a solid understanding of the basics of C#. From variables and data types to control structures and simple functions, each exercise is crafted to challenge you incrementally as you build confidence in coding in C#.