Comprenda brevemente la estructura de datos de JavaScript y la pila de algoritmos.

1. Comprenda la pila

: (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.

2. Escribir pila para el código fuente del método de proceso.

2.1 Piense en

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.

2.2 Métodos que deben implementarse

1. push (elemento ) agrega uno o más elementos a la parte superior de la pila
2. pop () elimina el elemento superior y devuelve el elemento eliminado
3. peek () devuelve el elemento en la parte superior de la pila
4. isEmpty () es se usa para determinar si la pila está vacía, estará vacía.
5. clear() se usa para borrar los elementos de la pila.
6. 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.

2.3 Implementación del código fuente, llame a la clase

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())

de Console.log(stack.size())

:

3. Escriba código fuente utilizando métodos orientados a objetos.

3.1 Pensando

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.

3.2 Métodos que deben implementarse

1. push (elemento ) agrega uno o más elementos a la parte superior de la pila
2. pop () elimina el elemento superior y devuelve el elemento eliminado
3. peek () devuelve el elemento en la parte superior de la pila
4. isEmpty () es se usa para determinar si la pila está vacía, vacía está vacía
5. clear() se usa para borrar los elementos de la pila
6. size() se usa para devolver el número de elementos en la pila
7. 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.

3.3 Código fuente y clase de uso

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())
  

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.