Méthode d'implémentation de la pile dans les compétences JavaScipt_javascript

L'étape suivante est la première partie de la structure des données, pile.
Stack est une collection ordonnée qui suit le principe du dernier entré, premier sorti (LIFO, nom complet : Last In First Out). Le haut de la pile est toujours l’élément le plus récent.
Par exemple : une pile est comme une pile de livres placée dans une boîte. Si vous souhaitez prendre le livre du bas, vous devez d'abord retirer le livre du haut. (Bien sûr, vous ne pouvez pas prendre le livre ci-dessous en premier)
Vous pouvez également le comprendre en regardant le schéma.

Implémentation de la stack en JavaScipt
Tout d’abord, créez un constructeur.

/**
 * 栈的构造函数
 */
function Stack() {

 // 用数组来模拟栈
 var item = [];
}

La pile doit avoir les méthodes suivantes :

• push(element(s)) : Ajouter plusieurs éléments en haut de la pile
  
• pop() : Supprime et renvoie l'élément supérieur de la pile
  
• peek() : Renvoie l'élément supérieur de la pile
  
• isAmpty : Vérifiez si la pile est vide, si elle est vide, retournez true
  
• clear : Supprimer tous les éléments de la pile
  
• size : Renvoie le nombre d'éléments dans la pile.
  
• print : Afficher tout le contenu de la pile sous forme de chaîne

Mise en place de la méthode push
Explication : de nouveaux éléments doivent être ajoutés à la pile et la position de l'élément est à la fin de la file d'attente. En d’autres termes, nous pouvons utiliser la méthode push du tableau pour simuler l’implémentation.
Mise en œuvre :

/**
 * 将元素送入栈，放置于数组的最后一位
 * @param {Any} element 接受的元素，不限制类型
 */
this.push = function(element) {
 items.push(element);
};

Mise en place de la méthode pop
Explication : Il est nécessaire de faire apparaître l'élément supérieur de la pile et de renvoyer la valeur sautée en même temps. Vous pouvez utiliser la méthode pop du tableau pour simuler l'implémentation.
Mise en œuvre :

/**
 * 弹出栈顶元素
 * @return {Any} 返回被弹出的值
 */
this.pop = function() {
 return items.pop();
};

Mise en place de la méthode peek
Remarque : l'affichage de l'élément supérieur de la pile peut être obtenu en utilisant la longueur du tableau.
Mise en œuvre :

/**
 * 查看栈顶元素
 * @return {Any} 返回栈顶元素
 */
this.peek = function() {
 return items[items.length - 1];
}

Mise en œuvre d'autres méthodes
Remarque : Les trois premières constituent le cœur de la méthode stack et les méthodes restantes sont répertoriées ici en même temps. Parce que la file d’attente dont il sera question ci-dessous chevauchera grandement cette partie.
Mise en œuvre :

/**
 * 确定栈是否为空
 * @return {Boolean} 若栈为空则返回true,不为空则返回false
 */
this.isAmpty = function() {
 return items.length === 0
};

/**
 * 清空栈中所有内容
 */
this.clear = function() {
 items = [];
};

/**
 * 返回栈的长度
 * @return {Number} 栈的长度
 */
this.size = function() {
 return items.length;
};

/**
 * 以字符串显示栈中所有内容
 */
this.print = function() {
 console.log(items.toString());
};

Application pratique
Il existe de nombreuses applications pratiques de la pile. Il existe une fonction dans le livre qui convertit le nombre décimal en binaire. (Si vous ne savez pas comment calculer le binaire, vous pouvez utiliser Baidu.) Voici le code source de la fonction.
Le principe est de saisir le nombre à convertir, de diviser par deux en continu et d'arrondir. Et enfin, utilisez une boucle while pour concaténer tous les nombres de la pile en une chaîne pour la sortie.

/**
 * 将10进制数字转为2进制数字
 * @param {Number} decNumber 要转换的10进制数字
 * @return {Number}      转换后的2进制数字
 */
function divideBy2(decNumber) {

 var remStack = new Stack(),
  rem,
  binaryString = '';

 while (decNumber > 0) {
  rem = Math.floor(decNumber % 2);
  remStack.push(rem);
  decNumber = Math.floor(decNumber / 2);
 }

 while (!remStack.isAmpty()) {
  binaryString += remStack.pop().toString();
 }

 return binaryString;
};

À ce stade, l'étude de la pile est terminée. J'espère qu'il sera utile pour tout le monde d'apprendre à implémenter la pile en JavaScript.