Implementación de Stack en JavaScript

En este artículo, estaríamos implementando Stack Data Structure en Javascript. Stack es una estructura de datos muy útil y tiene una amplia gama de aplicaciones. Stack es una estructura de datos lineal en la que la adición o eliminación de elementos sigue un orden particular, es decir, LIFO (último en entrar, primero en salir) Y FILO (primero en entrar, último en salir).
Nota: Suponiendo que la pila pueda crecer dinámicamente, no estamos considerando la condición de desbordamiento.

Veamos un ejemplo de una clase de pila que usa una array en un script Java: –
Ejemplos:

// Stack class
class Stack {
  
    // Array is used to implement stack
    constructor()
    {
        this.items = [];
    }
  
    // Functions to be implemented
    // push(item)
    // pop()
    // peek()
    // isEmpty()
    // printStack()
}

Como puede ver en la definición anterior, hemos creado un esqueleto de una clase de pila que contiene un constructor en el que declaramos una array para implementar la pila. Por lo tanto, con la creación de un objeto de una clase de pila, este constructor se llamaría automáticamente.

Ahora veamos la implementación de cada método:

1. Empujar: agrega un elemento a la pila

   // push function push(element) {     // push element into the items     this.items.push(element); }

   Este método agrega un elemento en la parte superior de la pila.

2. Pop(): elimina un elemento de la pila, si la función se llama en una pila vacía, indica «Subdesbordamiento»

   // pop function pop() {     // return top most element in the stack     // and removes it from the stack     // Underflow if stack is empty     if (this.items.length == 0)         return "Underflow";     return this.items.pop(); }

   Este método devuelve el elemento superior de la pila y lo elimina. Devuelve el subdesbordamiento cuando se le llama en una pila vacía.

3. Peek() : devuelve la mayoría de los elementos superiores de la pila, pero no los elimina.

   // peek function peek() {     // return the top most element from the stack     // but does'nt delete it.     return this.items[this.items.length - 1]; }

   Devuelve el elemento superior sin quitarlo de la pila.

Métodos auxiliares

Estas son las tres operaciones básicas realizadas por una pila. Declaremos algún método auxiliar que puede ser útil mientras se trabaja con la pila.

1. isEmpty() : devuelve verdadero si la pila está vacía

   // isEmpty function isEmpty() {     // return true if stack is empty     return this.items.length == 0; }

   Devuelve verdadero si la pila está vacía.

2. printStack() : este método devuelve una string en la que se concatenan todos los elementos de una pila.

   // printStack function printStack() {     var str = "";     for (var i = 0; i < this.items.length; i++)         str += this.items[i] + " ";     return str; }

   Nota: se pueden declarar diferentes funciones auxiliares en la clase Stack según el requisito. Ahora que hemos terminado de definir la clase de pila, usémosla.

Funciones de muestra

En este ejemplo, crearíamos un objeto de clase de pila y probaríamos algunas funciones del mismo.

// creating object for stack class
var stack = new Stack();
  
// testing isEmpty and pop on an empty stack
  
// returns false
console.log(stack.isEmpty()); 
  
// returns Underflow
console.log(stack.pop()); 

Algunas funciones más de la clase de pila
Ejemplo:

// Adding element to the stack
stack.push(10);
stack.push(20);
stack.push(30);
  
// Printing the stack element
// prints [10, 20, 30]
console.log(stack.printStack());
  
// returns 30
console.log(stack.peek());
  
// returns 30 and remove it from stack
console.log(stack.pop());
  
// returns [10, 20]
console.log(stack.printStack()); 

Una vez que hayamos terminado de implementar y probar la clase de pila, ahora podemos usarla en diferentes aplicaciones.

Aplicación: Evaluación de Expresión Postfix

En este ejemplo, usaríamos la clase de pila anterior para evaluar la expresión de sufijo

// Performs Postfix Evaluation on a given exp
function postFixEvaluation(exp)
{
    var stack = new Stack();
    for (var i = 0; i < exp.length; i++) {
        var c = exp[i];
        if (!isNaN(c))
            stack.push(c - '0');
        else {
            var val1 = stack.pop();
            var val2 = stack.pop();
            if (val1 == "Underflow" || val2 == "Underflow")
                return "Can't perform postfix evaluation";
            switch (c) {
            case '+':
                stack.push(val2 + val1);
                break;
  
            case '-':
                stack.push(val2 - val1);
                break;
  
            case '/':
                stack.push(val2 / val1);
                break;
  
            case '*':
                stack.push(val2 * val1);
                break;
            }
        }
    }
  
    return stack.pop();
}
  
// calling the above method
// returns 9
console.log(postFixEvaluation("235*+8-")); 
  
// returns postfix evaluation can't be performed
console.log(postFixEvaluation("23*+"));

Este artículo es una contribución de Sumit Ghosh . Si le gusta GeeksforGeeks y le gustaría contribuir, también puede escribir un artículo usando contribuya.geeksforgeeks.org o envíe su artículo por correo a contribuya@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks.

Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.