Structure de données_2: pile

Empiler

Écrivez au début

• Structure linéaire, les opérations de pile sont un sous-ensemble des opérations de tableau
• Dans la structure de données premier entré dernier sorti (LIFO), les éléments ne peuvent être ajoutés qu'à une extrémité et les éléments ne peuvent être retirés qu'à une extrémité. Cette extrémité est appelée le haut de la pile.

La réalisation de la pile: multiplexage de tableaux dynamiques, et construction d'ArrayStack <E> au moyen d'interfaces

• Interface de pile:

    public interface Stack<E> {
    
        /**
         * 获取栈内元素容量
         * @return
         */
        int getSize();
    
        /**
         * 栈空判断
         * @return
         */
        boolean isEmpty();
    
        /**
         * 入栈
         * @param e
         */
        void push(E e);
    
        /**
         * 出栈
         * @return
         */
        E pop();
    
        /**
         * 获取栈顶元素
         * @return
         */
        E peek();
    }
  

• Classe d'implémentation d'interface: ArrayStack <E>

    public class ArrayStack<E> implements Stack<E> {
  
        private Array<E> array;
    
        public ArrayStack(int capacity) {
            array = new Array<>(capacity);
        }
    
        public ArrayStack() {
            array = new Array<>();
        }
    
        public int getCapacity() {
            return array.getCapacity();
        }
    
        @Override
        public int getSize() {
            return array.getSize();
        }
    
        @Override
        public boolean isEmpty() {
            return array.isEmpty();
        }
    
        @Override
        public void push(E e) {
            array.addLast(e);
        }
    
        @Override
        public E pop() {
    		// 等同于：array.remove(size - 1);
            return array.removeLast();
        }
    
        @Override
        public E peek() {
    		// 等同于：array.get(size - 1);
            return array.getLast();
        }
    
        @Override
        public String toString() {
            return "stack.ArrayStack{" +
                    "array=" + array +
                    '}';
        }
    }
  

application

• Opération Editor-Undo (Undo): L'opération d'annulation annulera toujours l'opération précédente de l'étape en cours et l'opération de pile sera exécutée séquentiellement à partir de la pile d'opérations.
• Pile d'appels du système d'exploitation: enregistrez le point d'interruption de l'exécution de l'instruction imbriquée du programme et poussez l'enregistrement du point d'interruption dans la pile (point d'exécution de la sous-fonction analogue, répétez le point d'exécution de la sous-fonction dans l'opération de pile jusqu'au est appelée), l'opération pop est l'opération consistant à renvoyer le résultat du point d'interruption inférieur à son tour.
• Correspondance Editor-Bracket, prenez Likou-T20 comme exemple:

  • Question:

      给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串，判断字符串是否有效。
      有效字符串需满足：
      	左括号必须用相同类型的右括号闭合。
      	左括号必须以正确的顺序闭合。
      注意空字符串可被认为是有效字符串。
    

  • Solution: caractéristiques d'utilisation de la pile, l'élément de balayage de chaîne de caractères donnée, les catégories de caractères parenthèse gauche ( (, [, { ), effectuer des opérations de pile pour les classes de caractères de parenthèses non à gauche: en prenant la logique de couplage d'élément de début pour déterminer, en traversant la liaison a réussi et après le fin, la pile est vide comme une correspondance réussie.

      import java.util.Stack;
      class Solution {
          public boolean isValid(String s) {
              Stack<Character> stack = new Stack<>();
              for (int i = 0; i < s.length(); i ++) {
                  char c = s.charAt(i);
                  if (c == '(' || c =='[' || c == '{') {
                      stack.push(c);
                  } else {
                      if (stack.isEmpty()) {
                          return false;
                      }
                      if (c == ')' && stack.pop() != '(') {
                          return false;
                      }
                      if (c == ']' && stack.pop() != '[') {
                          return false;
                      }
                      if (c == '}' && stack.pop() != '{') {
                          return false;
                      }
                  }
              }
              return stack.isEmpty();
          }
      }