Entenda resumidamente a estrutura de dados JavaScript e a pilha de algoritmos

1. Entenda a pilha

: (pilha) também conhecida como pilha, é uma tabela linear com operações limitadas. Segue o último a entrar, primeiro a sair (LIFO)

no topo da pilha : uma lista linear que restringe as operações de inserção e exclusão apenas ao final da tabela, e

na parte inferior da pilha : uma lista linear que restringe as operações de inserção e exclusão apenas para a cabeça.

Pushing : Inserir um novo elemento em uma pilha também é chamado de push, push ou push. É colocar o novo elemento no topo do elemento superior da pilha, tornando-o o novo elemento superior da pilha

popping : deletando de uma

pilha;

O elemento stack também é chamado de popping ou popping off the stack. Ele exclui o elemento superior da pilha e faz com que seus elementos adjacentes se tornem o novo elemento superior da pilha.

2. Escreva a pilha para o código-fonte do método de processo

2.1 Pense no

que é orientado a processos:

Orientado a processos é analisar as etapas para resolver o problema e

depois usar funções

para implementá-las. Você só precisa executá-las e chamá -las passo a passo.

2.2 Métodos que precisam ser implementados

1. push (element ) adiciona um ou mais elementos ao topo da pilha
2. pop () exclui o elemento do topo e retorna o elemento removido
3. peek () retorna o elemento no topo da pilha
4. isEmpty () é usado para determinar se a pilha está vazia, ela estará vazia.
5. clear() é usado para limpar os elementos da pilha.
6. size() é usado para retornar o número de elementos na pilha

. como o implementamos

Primeiro, pegamos emprestado o método array para implementá-lo, então precisamos criar

um array vazio para simular a pilha.

2.3 Implementação do código-fonte e chamar a classe

para construir uma classe, usar um array para simulá-la e

escrever vários métodos na classe

para chamar parcialmente o método do array.

Em geral, o método de usar uma classe para agrupar

um array é realizar a simulação da pilha

class Stack {
   construtor() {
       este.item = []
         }
   empurrar(elemento) {
        este.item.push(elemento)
               }
   pop() {
      retorne este.item.pop()
          }
   espiar() {
       retorne este.item[este.item.comprimento - 1]
            }
   estáVazio() {
       retornar este.item.length === 0
            }
   claro() {
         este.item = []
   tamanho() {
          retorne este.item.length
            }
        }
//Instancia a classe Stack const stack = new Stack()
pilha.push(4)
pilha.push(6)
console.log(pilha.pop())
console.log(stack.peek())
console.log(stack.isEmpty())

do console.log(stack.size())

:

3. Escreva o código-fonte usando métodos orientados a objetos

3.1 Pensando

em orientação a objetos:

É decompor as coisas que constroem o problema em vários objetos .

O objeto não é estabelecido para completar uma determinada etapa, mas para

descrever o comportamento de algo no processo de resolução do problema.

3.2 Métodos que precisam ser implementados

1. push (element ) adiciona um ou mais elementos ao topo da pilha
2. pop () exclui o elemento do topo e retorna o elemento removido
3. peek () retorna o elemento no topo da pilha
4. isEmpty () é usado para determinar se a pilha está vazia, vazio está vazio
5. clear() é usado para limpar os elementos da pilha
6. size() é usado para retornar o número de elementos na pilha
7. toString() é usado para imprimir a pilha no formato de uma string

. Então, ao implementar esta classe, usamos objetos para a pilha de simulação.

3.3 Código-fonte e classe de uso

class Stack {
   construtor() {
      esta.contagem=0
      isto.items = {}
            }
   empurrar(elemento) {
      this.items[this.count]=elemento
      isto.contar++
            }
    pop() {
       if(this.isEmpty()){
           retornar indefinido
          }
       esta.contagem--
       resultado const=this.items[this.count]
       exclua este.items[this.count]
       resultado de retorno
            }
    espiar() {
          if(this.isEmpty()){
               retornar indefinido
               }
         retorne este.items[this.count-1]
            }
    estáVazio() {
         retorne esta.contagem===0
            }
    claro() {
        isto.items={}
        esta.contagem=0
          }
    tamanho() {
       retornar isto.count
           }
    toString(){
       if(this.isEmpty()){
        retornar indefinido
               }
         deixe objectString=`${this.items[0]}`
          for(deixe i=1;i<this.count;i++){
               objectString=`${objectString},${this.items[i]}`
               }
         retornar objetoString
            }
        }

  pilha const = nova pilha()
  pilha.push(23)
  pilha.push(34)
  pilha.push(80)
  console.log(pilha.pop())
  console.log(stack.peek())
  console.log(stack.isEmpty())
  console.log(stack.size())
  

console.log(stack.toString())

usa objetos para simular pilhas, ele usa key:value

para armazenar dados. Por exemplo, this.items[this.count]=element usa

this.count para registrar nesta estrutura. tamanho da pilha

Quando inserimos um número nela, atribuímos count como a chave

e inserimos o valor como o valor. Neste momento, você precisa alterar this.count++.

Em relação a pop() e peek(), o método toString() precisa

primeiro determinar se a pilha está vazia, ele retornará indefinido.