
: (pila) también conocida como pila, es una tabla lineal con operaciones limitadas. Siga la parte superior de la pila de último en entrar, primero en salir (LIFO)
: una lista lineal que restringe las operaciones de inserción y eliminación solo hasta el final de la tabla, y
la parte inferior de la pila : una lista lineal que restringe las operaciones de inserción y eliminación sólo a la cabeza.
Empujar : Insertar un nuevo elemento en una pila también se llama empujar, empujar o empujar. Es colocar el nuevo elemento encima del elemento superior de la pila, convirtiéndolo en el nuevo elemento superior de la pila
. El elemento de pila también se llama sacar o sacar de la pila. Elimina el elemento superior de la pila y hace que sus elementos adyacentes se conviertan en el nuevo elemento superior de la pila.

qué es la orientación a procesos:
la orientación a procesos es analizar los pasos para resolver el problema y
luego usar funciones
para implementarlas. Solo necesita ejecutarlas y llamarlas paso a paso.
- push (elemento ) agrega uno o más elementos a la parte superior de la pila
- pop () elimina el elemento superior y devuelve el elemento eliminado
- peek () devuelve el elemento en la parte superior de la pila
- isEmpty () es se usa para determinar si la pila está vacía, estará vacía.
- clear() se usa para borrar los elementos de la pila.
- size() se usa para devolver el número de elementos en la pila.
Antes de implementarlo, pensemos en ello. cómo lo implementamos
Primero, tomamos prestado el método de matriz para implementarlo, por lo que necesitamos crear
una matriz vacía para simular la pila.
para construir una clase, use una matriz para simularla y
escriba varios métodos en la clase
para llamar parcialmente al método de la matriz.
En general, el método de usar una clase para envolver
una matriz es realizar la simulación de la
clase de pila Stack {
constructor() {
este.elemento = []
}
empujar (elemento) {
este.elemento.push(elemento)
}
estallido() {
devolver este.item.pop()
}
mirar() {
devolver este.elemento[este.elemento.longitud - 1]
}
está vacío() {
devolver this.item.length === 0
}
claro() {
este.elemento = []
tamaño() {
devolver esta.longitud.del.elemento
}
}
//Crea una instancia de la clase Stack const stack = new Stack()
pila.push(4)
pila.push(6)
consola.log(pila.pop())
consola.log(pila.peek())
console.log(pila.isEmpty())
Resultados de Console.log(stack.size())
:

en orientado a objetos:
Es descomponer las cosas que construyen el problema en varios objetos .
El objeto no se establece para completar un determinado paso, sino para
describir el comportamiento de algo en el proceso de resolución del problema.
- push (elemento ) agrega uno o más elementos a la parte superior de la pila
- pop () elimina el elemento superior y devuelve el elemento eliminado
- peek () devuelve el elemento en la parte superior de la pila
- isEmpty () es se usa para determinar si la pila está vacía, vacía está vacía
- clear() se usa para borrar los elementos de la pila
- size() se usa para devolver el número de elementos en la pila
- toString() se usa para imprimir la pila en el formulario de una cadena
Luego, al implementar esta clase, usamos objetos para la pila de simulación.
class Stack {
constructor() {
este.count=0
estos.elementos = {}
}
empujar (elemento) {
this.items[this.count]=elemento
este.count++
}
estallido() {
si(this.isEmpty()){
regresar indefinido
}
este.cuenta--
resultado constante=this.items[this.count]
eliminar this.items[this.count]
resultado de retorno
}
mirar() {
si(this.isEmpty()){
regresar indefinido
}
devolver this.items[this.count-1]
}
está vacío() {
devolver este.count===0
}
claro() {
this.items={}
este.count=0
}
tamaño() {
devolver esto.count
}
toString(){
si(this.isEmpty()){
regresar indefinido
}
dejar objectString=`${this.items[0]}`
for(let i=1;i<this.count;i++){
objectString=`${objectString},${this.items[i]}`
}
devolver cadena de objeto
}
}
pila constante = nueva pila()
pila.push(23)
pila.push(34)
pila.push(80)
consola.log(pila.pop())
consola.log(pila.peek())
console.log(pila.isEmpty())
consola.log(pila.tamaño())
Cuando console.log(stack.toString())
usa objetos para simular pilas, usa key:value
para almacenar datos. Por ejemplo, this.items[this.count]=element usa
this.count para registrar en esta estructura. tamaño de la pila.
Cuando insertamos un número en ella, asignamos el recuento como clave
e insertamos el valor como valor. En este momento, debe cambiar this.count ++.
Con respecto a pop () y peek (), el método toString () primero debe
determinar si la pila está vacía y devolverá indefinido.