¿Una pila es una estructura de datos lineal simple que funciona como una pila de platos?️. Sigue el principio de último en entrar, primero en salir (LIFO). Piense en ello como una pila de platos: solo puede agregar o quitar platos de la parte superior de la pila.

Para comprender mejor la pila, ¿emprendemos un breve viaje de imaginación?.
Imagina que estás en un restaurante elegante ?️ y el personal de la cocina se está preparando para una noche ajetreada ?‍?. En el área de los platos, hay una gran pila de platos esperando a ser utilizados. A medida que llegan los comensales y llegan los pedidos, el personal toma los platos de la parte superior de la pila. Cuando se agregan platos limpios, van directamente encima. Este sencillo sistema garantiza que los platos en la parte inferior de la pila que han estado allí por más tiempo se usen al final, mientras que los platos recién limpios en la parte superior se usan primero ✨.

Así es, en esencia, cómo funciona una estructura de datos Stack. Una pila es una estructura de datos lineal que sigue el principio de último en entrar, primero en salir (LIFO). Al igual que con nuestra pila de platos, el último elemento agregado a una pila es el primero en eliminarse.

Tabla de contenido

En este tutorial completo sobre la estructura de datos de la pila, exploraremos los siguientes temas con un enfoque sencillo y apto para principiantes:

1. ¿Qué es una pila?
2. Pros y contras de usar Stack
3. Aplicaciones de pilas en el mundo real
4. Operaciones clave en una pila
5. Implementación de pila en JavaScript
6. Conclusión

¿Estás listo? Vamos a sumergirnos

¿Qué es una pila?

Una pila es una estructura de datos lineal que sigue el principio de último en entrar, primero en salir (LIFO). Esto significa que el último elemento agregado a la pila será el primero en eliminarse. Piense en ello como una pila de libros: solo puede agregar o quitar libros desde la parte superior de la pila.

Pros y contras de usar Stack

Antes de continuar con el flujo y escribir algunos códigos, es excelente comprender dónde y dónde no usar Stack. La siguiente tabla proporciona detalles explícitos de los pros y los contras de Stack.

Operaciones clave en una pila

Las operaciones fundamentales que se pueden realizar en una pila son:

1. push(): Agrega un elemento a la parte superior de la pila.
2. pop(): elimina el elemento superior de la pila.
3. peek(): Devuelve el elemento superior de la pila sin eliminarlo.
4. isEmpty(): Comprueba si la pila está vacía.
5. size(): Devuelve el número de elementos en la pila.

Aplicaciones de pilas en el mundo real

Las pilas están en todas partes en la informática y el desarrollo de software. Estas son algunas aplicaciones comunes:

1. Funcionalidad Deshacer: en editores de texto o software de diseño gráfico, cada acción se coloca en una pila. Cuando presionas "deshacer", la acción más reciente se elimina de la pila y se invierte.

2. Historial del navegador: cuando visitas una página nueva, se coloca en una pila. El botón "atrás" saca la página actual de la pila y revela la anterior.

3. Pila de llamadas a funciones: en los lenguajes de programación, las llamadas a funciones se gestionan mediante una pila. Cuando se llama a una función, se coloca en la pila de llamadas. Cuando regresa, se desprende.

4. Evaluación de expresiones: Las pilas se utilizan para evaluar expresiones aritméticas, especialmente aquellas en notación posfija.

5. Algoritmos de retroceso: en problemas como la resolución de laberintos o acertijos, las pilas pueden realizar un seguimiento del camino tomado, lo que permite retroceder fácilmente cuando sea necesario.

Implementación de pila en JavaScript

Ahora, implementemos una pila en JavaScript. Es importante saber que existen diferentes formas de implementar una pila en JavaScript. Una de las formas comunes de implementar una pila es usar una matriz, otra forma es usar una lista vinculada. En este artículo, implementaremos una pila usando una lista vinculada (lista vinculada individualmente).

Implementar pila usando lista vinculada

Espero que todavía recuerdes cómo funciona la lista enlazada. Es posible que necesites consultar la implementación de la lista vinculada en uno de nuestros artículos anteriores de esta misma serie.

Cómo implementar una lista enlazada individualmente en JavaScript

¿La gran solución? ・ 4 de octubre

#javascript #principiantes #programación #dsa

Ahora, comencemos a implementar nuestra pila usando una lista enlazada individualmente. ¿Debemos?

Primero, crearemos una clase de Nodo para representar el elemento individual de nuestra pila.

class Node {
  constructor(data) {
    this.data = data;
    this.next = null;
  }
}

Luego, crearemos una clase Stack para representar nuestra pila.

class Stack {
  constructor() {
    this.top = null;
    this.size = 0;
  }

  // Stack Operations will be implemented here ?
}

Operación de empuje

La operación de inserción agrega un nuevo elemento a la parte superior de la pila. Crea un nuevo StackNode, establece su siguiente puntero en la parte superior actual y luego actualiza la parte superior para que apunte a este nuevo nodo. Finalmente, incrementa el tamaño.

  // Push element to the top of the stack
  push(element) {
    const newNode = new Node(element);
    newNode.next = this.top;
    this.top = newNode;
    this.size  ;
  }

Operación pop

La operación emergente elimina el elemento superior de la pila. Primero comprueba si la pila está vacía. Si es así, devuelve un mensaje de error. De lo contrario, elimina el elemento superior, actualiza el puntero superior al siguiente nodo y disminuye el tamaño. Finalmente, devuelve el elemento eliminado.

  // Remove and return the top element
  pop() {
    if (this.isEmpty()) {
      return "Stack is empty";
    }
    const poppedElement = this.top.data;
    this.top = this.top.next;
    this.size--;
    return poppedElement;
  }

Operación de vistazo

La operación de vista previa devuelve el elemento superior sin eliminarlo. Primero comprueba si la pila está vacía. Si es así, devuelve un mensaje de error. De lo contrario, devuelve los datos del elemento superior.

  // Return the top element without removing it
  peek() {
    if (this.isEmpty()) {
      return "Stack is empty";
    }
    return this.top.data;
  }

Operación está vacía

La operación isEmpty comprueba si la pila está vacía. Devuelve verdadero si la pila está vacía y falso en caso contrario.

  // Check if the stack is empty
  isEmpty() {
    return this.size === 0;
  }

Operación getSize

La operación getSize devuelve el tamaño de la pila. Devuelve el número de elementos de la pila.

  // Return the size of the stack
  getSize() {
    return this.size;
  }

Operación de impresión

La operación de impresión imprime la pila. Devuelve los datos del elemento superior.

  // Print the stack
  print() {
    let current = this.top;
    let result = "";
    while (current) {
      result  = current.data   " ";
      current = current.next;
    }
    console.log(result.trim());
  }

Ejemplo de uso

// Usage example
const customStack = new CustomStack();
customStack.push(10);
customStack.push(20);
customStack.push(30);
console.log(customStack.pop()); // 30
console.log(customStack.peek()); // 20
console.log(customStack.getSize()); // 2
console.log(customStack.isEmpty()); // false
customStack.print(); // 20 10

En esta implementación, utilizamos una estructura de lista enlazada (lista enlazada individualmente) para representar nuestra pila. Cada elemento es un Nodo con un valor de datos y una referencia al siguiente Nodo. La parte superior de la pila es siempre el nodo agregado más recientemente.

Conclusión

Las pilas son una estructura de datos fundamental en informática que sigue el principio Último en entrar, primero en salir (LIFO). Se utilizan en diversas aplicaciones, incluida la gestión de llamadas a funciones, la implementación de funciones de deshacer y la evaluación de expresiones aritméticas.

En este tutorial, cubrimos los conceptos básicos de las pilas, los pros y los contras de usarlas y su implementación en JavaScript (usando una lista vinculada). Comprender las pilas no se trata solo de saber cómo implementarlas, sino también de reconocer cuándo son la herramienta adecuada para resolver un problema.

A medida que continúe su viaje en el desarrollo de software, descubrirá que las pilas son una herramienta indispensable en su kit de herramientas de resolución de problemas. Son simples pero poderosos, y dominarlos mejorará significativamente su capacidad para diseñar algoritmos y estructuras de datos eficientes.

Manténgase actualizado y conectado

Para garantizar que no se pierda ninguna parte de esta serie y conectarse conmigo para discusiones más profundas sobre desarrollo de software (web, servidor, móvil o scraping/automatización), estructuras de datos y algoritmos, y otras tecnologías interesantes. temas, sígueme en:

• GitHub
• Linkedin
• X (Twitter)

Estén atentos y felices codificando ?‍??