Installation and Configuration
Programming Methodology
Video Tutorials

Implementing a Custom Stack in C#

In this exercise, you need to implement a stack in C#. A stack is a data structure that follows the LIFO (Last In, First Out) principle, meaning the last element to enter is the first one to exit. In this exercise, you will need to create a class for the stack, allowing you to insert elements at the top of the stack and remove elements from the top. The goal of this exercise is to help you understand how stacks work and how to manage them in C#.

In this exercise, you should implement key methods like Push (to add elements), Pop (to remove elements), and Peek (to view the top element without removing it). Additionally, you will need to handle cases like when the stack is empty or full, and how to manage these events to prevent errors.

By completing this exercise, you will have learned how to use stacks in C# and how to apply them in situations where data access follows a "last in, first out" order, such as in reverse processing or tracking application states.



Group

Dynamic Memory Management in C#

Objective

1. Create a Stack class that supports integer values.
2. Implement the methods Push (to add elements), Pop (to remove elements), and Peek (to see the top element without removing it).
3. Handle edge cases, such as attempting to remove an element from an empty stack.
4. Demonstrate the functionality by adding, removing, and peeking elements in the stack.

In this exercise, you need to implement a stack in C#. A stack is a data structure that follows the LIFO (Last In, First Out) principle, meaning the last element to enter is the first one to exit. In this exercise, you will need to create a class for the stack, allowing you to insert elements at the top of the stack and remove elements from the top. The goal of this exercise is to help you understand how stacks work and how to manage them in C#.

Example C# Exercise

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

class CustomStack
{
    // List to store stack elements
    private List stack;

    // Constructor to initialize the stack
    public CustomStack()
    {
        stack = new List();
    }

    // Method to add an element to the top of the stack
    public void Push(int item)
    {
        stack.Add(item);
        Console.WriteLine($"Pushed: {item}");
    }

    // Method to remove and return the top element of the stack
    public int Pop()
    {
        if (stack.Count == 0)
        {
            throw new InvalidOperationException("Stack is empty.");
        }

        // Get the last element (top of the stack)
        int topItem = stack[stack.Count - 1];

        // Remove the last element from the stack
        stack.RemoveAt(stack.Count - 1);
        Console.WriteLine($"Popped: {topItem}");
        return topItem;
    }

    // Method to return the top element without removing it
    public int Peek()
    {
        if (stack.Count == 0)
        {
            throw new InvalidOperationException("Stack is empty.");
        }

        return stack[stack.Count - 1];
    }

    // Method to check if the stack is empty
    public bool IsEmpty()
    {
        return stack.Count == 0;
    }
}

class Program
{
    static void Main()
    {
        // Create an instance of the CustomStack class
        CustomStack stack = new CustomStack();

        // Add elements to the stack
        stack.Push(10);
        stack.Push(20);
        stack.Push(30);

        // Peek at the top element without removing it
        Console.WriteLine($"Top element (Peek): {stack.Peek()}");

        // Remove elements from the stack
        stack.Pop();
        stack.Pop();

        // Peek again after popping some elements
        Console.WriteLine($"Top element after popping (Peek): {stack.Peek()}");

        // Remove the last element
        stack.Pop();

        // Check if the stack is empty
        Console.WriteLine($"Is the stack empty? {stack.IsEmpty()}");
    }
}

 Output

Pushed: 10
Pushed: 20
Pushed: 30
Top element (Peek): 30
Popped: 30
Popped: 20
Top element after popping (Peek): 10
Popped: 10
Is the stack empty? True

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#.