Instalación y Configuración
Metodología Programación
Video Tutoriales

Implementación De Una Pila Personalizada En C#

En este ejercicio, deberá implementar una pila en C#. Una pila es una estructura de datos que sigue el principio LIFO (Último en entrar, primero en salir), lo que significa que el último elemento en entrar es el primero en salir. En este ejercicio, deberá crear una clase para la pila que le permita insertar y eliminar elementos en la parte superior. El objetivo de este ejercicio es ayudarle a comprender cómo funcionan las pilas y cómo administrarlas en C#.

En este ejercicio, deberá implementar métodos clave como Push (para agregar elementos), Pop (para eliminar elementos) y Peek (para ver el elemento superior sin eliminarlo). Además, deberá gestionar casos como cuando la pila está vacía o llena, y cómo administrar estos eventos para evitar errores.

Al completar este ejercicio, habrá aprendido a usar pilas en C# y a aplicarlas en situaciones donde el acceso a los datos sigue el orden "último en entrar, primero en salir", como en el procesamiento inverso o el seguimiento de estados de aplicaciones.



Grupo

Gestión Dinámica de Memoria en C#

Objectivo

1. Cree una clase Stack que admita valores enteros.
2. Implemente los métodos Push (para añadir elementos), Pop (para eliminar elementos) y Peek (para ver el elemento superior sin eliminarlo).
3. Gestione casos extremos, como intentar eliminar un elemento de una pila vacía.
4. Demuestre la funcionalidad añadiendo, eliminando y mirando elementos en la pila.

En este ejercicio, deberá implementar una pila en C#. Una pila es una estructura de datos que sigue el principio LIFO (último en entrar, primero en salir), lo que significa que el último elemento en entrar es el primero en salir. En este ejercicio, deberá crear una clase para la pila que le permita insertar y eliminar elementos en la parte superior de la pila. El objetivo de este ejercicio es ayudarle a comprender cómo funcionan las pilas y cómo administrarlas en C#.

Ejemplo de ejercicio en C#

 Copiar código C# 
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

Comparte este ejercicio de C#

Practica más ejercicios C# de Gestión Dinámica de Memoria en C#

¡Explora nuestro conjunto de ejercicios de práctica de C#! Diseñados específicamente para principiantes, estos ejercicios te ayudarán a desarrollar una sólida comprensión de los fundamentos de C#. Desde variables y tipos de datos hasta estructuras de control y funciones simples, cada ejercicio está diseñado para desafiarte gradualmente a medida que adquieres confianza en la programación en C#..