Comprendre brièvement la structure des données JavaScript et la pile d'algorithmes

1. Comprendre la pile

: (stack) aussi appelée pile, c'est une table linéaire aux opérations limitées. Suivez le dernier entré, premier sorti (LIFO)

en haut de la pile : une liste linéaire qui restreint les opérations d'insertion et de suppression uniquement à la fin du tableau, et

en bas de la pile : une liste linéaire qui restreint les opérations d'insertion et de suppression. seulement à la tête.

Pushing : L'insertion d'un nouvel élément dans une pile est également appelée push, push ou push. Il s'agit de placer le nouvel élément au-dessus de l'élément supérieur de la pile, ce qui en fait le nouvel élément supérieur de la pile

. L'élément de pile est également appelé popping ou popping de la pile. Il supprime l'élément supérieur de la pile et fait de ses éléments adjacents le nouvel élément supérieur de la pile.

2. Écrivez la pile pour le code source de la méthode de processus

2.1 Réfléchissez à

ce qu'est l'orientation processus :

L'orientation processus consiste à analyser les étapes pour résoudre le problème,

puis à utiliser des fonctions

pour les mettre en œuvre. Il vous suffit de les exécuter et de les appeler étape par étape.

2.2 Méthodes à implémenter

1. push (element ) ajoute un ou plusieurs éléments en haut de la pile
2. pop () supprime l'élément supérieur et renvoie l'élément supprimé
3. peek () renvoie l'élément en haut de la pile
4. isEmpty () est utilisé pour déterminer si la pile est vide.
5. clear() est utilisé pour effacer les éléments de la pile.
6. size() est utilisé pour renvoyer le nombre d'éléments dans la pile.

Avant de l'implémenter, réfléchissons. comment nous l'implémentons.Tout

d'abord, nous empruntons la méthode array pour l'implémenter, nous devons donc créer

un tableau vide pour simuler la pile.

2.3 Implémentation du code source et appelez la classe

pour créer une classe, utilisez un tableau pour la simuler et

écrivez diverses méthodes dans la classe

pour appeler partiellement la méthode du tableau.

En général, la méthode d'utilisation d'une classe pour envelopper

un tableau consiste à réaliser la simulation de la

classe de pile Stack {
   constructeur() {
       ceci.item = []
         }
   pousser(élément) {
        this.item.push(élément)
               }
   populaire() {
      renvoie this.item.pop()
          }
   coup d'oeil() {
       renvoyer this.item[this.item.length - 1]
            }
   estEmpty() {
       renvoyer this.item.length === 0
            }
   clair() {
         ceci.item = []
   taille() {
          renvoyer this.item.length
            }
        }
//Instancier la classe Stack const stack = new Stack()
pile.push(4)
pile.push(6)
console.log( stack.pop())
console.log(stack.peek())
console.log(stack.isEmpty())

Résultats

de Console.log(stack.size())

3. Écrivez le code source à l'aide de méthodes orientées objet

3.1 Penser

orienté objet :

Il s'agit de décomposer les éléments qui construisent le problème en plusieurs objets .

L'objet n'est pas établi pour accomplir une certaine étape, mais pour

décrire le comportement de quelque chose dans le processus de résolution du problème.

3.2 Méthodes à implémenter

1. push (element ) ajoute un ou plusieurs éléments en haut de la pile
2. pop () supprime l'élément supérieur et renvoie l'élément supprimé
3. peek () renvoie l'élément en haut de la pile
4. isEmpty () est utilisé pour déterminer si la pile est vide, vide est vide
5. clear() est utilisé pour effacer les éléments de la pile
6. size() est utilisé pour renvoyer le nombre d'éléments dans la pile
7. toString() est utilisé pour imprimer la pile sous la forme D'une chaîne.Ensuite

, lors de l'implémentation de cette classe, nous utilisons des objets pour simuler une pile.

3.3 Code source et classe d'utilisation

class Stack {
   constructeur() {
      ceci.count=0
      ceci.articles = {}
            }
   pousser(élément) {
      this.items[this.count]=élément
      ceci.count++
            }
    populaire() {
       si(this.isEmpty()){
           retour indéfini
          }
       ce.compte--
       résultat const=this.items[this.count]
       supprimer this.items[this.count]
       résultat de retour
            }
    coup d'oeil() {
          si(this.isEmpty()){
               retour indéfini
               }
         renvoyer this.items[this.count-1]
            }
    estEmpty() {
         renvoyer this.count===0
            }
    clair() {
        this.items={}
        ceci.count=0
          }
    taille() {
       renvoyer this.count
           }
    versChaîne(){
       si(this.isEmpty()){
        retour indéfini
               }
         laissez objectString=`${this.items[0]}`
          pour(soit i=1;i<this.count;i++){
               objectString=`${objectString},${this.items[i]}`
               }
         renvoyer une chaîne d'objet
            }
        }

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

console.log(stack.toString())

utilise des objets pour simuler des piles, il utilise key:value

pour stocker les données. Par exemple, this.items[this.count]=element utilise

this.count pour enregistrer dans cette structure. taille de la pile

Lorsque nous y insérons un nombre, nous attribuons le nombre comme clé

et insérons la valeur comme valeur. À ce stade, vous devez modifier this.count++.

Concernant pop() et peek(), la méthode toString() doit

d'abord déterminer si la pile est vide. Si elle est vide, elle retournera undefined.