Comment implémenter la pile en Java à l'aide de tableaux et de génériques ?

Java implémente la pile en exploitant les tableaux et les génériques. Cela crée une structure de données polyvalente et réutilisable qui fonctionne selon le principe du dernier entré, premier sorti (LIFO). Suivant ce principe, des éléments sont ajoutés et supprimés par le haut. En utilisant des tableaux comme base, il garantit une allocation et un accès efficaces à la mémoire. De plus, en incorporant des génériques, la pile est capable d'accueillir des éléments de différents types, améliorant ainsi sa polyvalence.

L'implémentation implique la définition d'une classe Stack contenant des paramètres de type génériques. Il comprend des méthodes de base telles que push(), pop(), peek() et isEmpty(). La gestion des cas extrêmes, tels que les débordements et les sous-débordements de pile, est également essentielle pour garantir une fonctionnalité transparente. Cette implémentation permet aux développeurs de créer des piles pouvant accueillir tout type d'élément en Java.

Pile en Java

En Java, la pile est une structure de données importante qui fonctionne selon le principe du dernier entré, premier sorti (LIFO). Il représente une collection d'éléments où les éléments les plus récemment ajoutés sont supprimés en premier. La classe stack en Java fournit une variété de méthodes pour manipuler efficacement les éléments. Par exemple, la méthode push vous permet d'ajouter un élément en haut de la pile, tandis que pop supprime et renvoie l'élément le plus haut. De plus, peek vous permet de récupérer l'élément supérieur sans le supprimer, et isEmpty vérifie si la pile est vide.

import java.util.Stack;

Stack<Type> stack = new Stack<>();
stack.push(element); // Adds 'element' to the top of the stack
Type topElement = stack.pop(); // Removes and returns the top element
Type peekElement = stack.peek(); // Retrieves the top element without removing it
boolean isEmpty = stack.isEmpty(); // Checks if the stack is empty

Méthode

Il existe différentes manières d'implémenter une pile en Java à l'aide de tableaux et de génériques, nous approfondirons les deux :

• Utilisez un tableau pour implémenter la pile

• Utilisez des génériques pour la mise en œuvre de la pile

Utilisez un tableau pour implémenter la pile

Lors de l'implémentation d'une pile en Java à l'aide d'un tableau, une structure de données est créée qui suit le principe du dernier entré, premier sorti (LIFO). Dans cette approche, les éléments sont stockés dans un tableau et la variable top est utilisée pour garder une trace de l'index qui représente l'élément le plus haut de la pile.

Les classes Stack contiennent généralement plusieurs méthodes. Ceux-ci incluent push(), qui ajoute un élément en haut de la pile, pop(), qui supprime et récupère l'élément supérieur, pe-ek(), qui vous permet d'afficher l'élément supérieur sans le supprimer, et isEmpty ( ), qui vérifie si la pile est vide.

Algorithme

• Créez un tableau pour stocker les éléments de la pile.

• Initialisez la variable nommée "top" à -1, indiquant que la pile est vide.

• Poussez les éléments sur la pile :

• Vérifiez si la pile est pleine (top == array.length - 1).

• Si la pile n'est pas pleine, incrémentez la variable "top" de 1 et affectez l'élément au tableau[top].

• Supprimez un élément de la pile :

• Vérifiez si la pile est vide (top == -1).

• Si la pile n'est pas vide, récupérez l'élément du tableau[top] et décrémentez la variable "top" de 1.

Exemple

public class Stack {
   private int[] array;
   private int top;
   
   public Stack(int capacity) {
      array = new int[capacity];
      top = -1;
   }
   
   public void push(int element) {
      if (top == array.length - 1) {
         System.out.println("Stack is full. Cannot push element.");
      } else {
         top++;
         array[top] = element;
         System.out.println("Pushed element: " + element);
      }
   }
   
   public int pop() {
      if (top == -1) {
         System.out.println("Stack is empty. Cannot pop element.");
         return -1;
      } else {
         int poppedElement = array[top];
         top--;
         System.out.println("Popped element: " + poppedElement);
         return poppedElement;
      }
   }
   
   public int peek() {
      if (top == -1) {
         System.out.println("Stack is empty. No element to peek.");
         return -1;
      } else {
         System.out.println("Peeked element: " + array[top]);
         return array[top];
      }
   }
   
   public boolean isEmpty() {
      return (top == -1);
   }
   
   public static void main(String[] args) {
      Stack stack = new Stack(5);
      
      stack.push(10);
      stack.push(20);
      stack.push(30);
      
      stack.pop();
      
      stack.push(40);
      stack.push(50);
      
      stack.pop();
      stack.pop();
      stack.pop();
      stack.pop();
   }
}

Sortie

Pushed element: 10
Pushed element: 20
Pushed element: 30
Popped element: 30
Pushed element: 40
Pushed element: 50
Popped element: 50
Popped element: 40
Popped element: 20
Popped element: 10

Utilisez des génériques pour l'implémentation de la pile

L'implémentation de la pile avec des génériques peut être utilisée comme structure de données commune. Il permet aux éléments d'être stockés et récupérés selon le principe du dernier entré, premier sorti (LIFO), offrant ainsi une flexibilité dans la gestion d'une variété de types de données. En tirant parti des génériques, cette pile adaptable devient un conteneur efficace capable de contenir des éléments de tout type, ce qui la rend extrêmement polyvalente et réutilisable.

Algorithme

• Créez une classe générique appelée Stack pour stocker les éléments dans la pile.

• À l'intérieur de la classe Stack, il existe un tableau privé ou une liste chaînée pour enregistrer ces éléments.

• La pile est initialisée à l'aide d'un constructeur qui alloue la mémoire nécessaire.

• Pour ajouter un élément en haut de la pile, vous devez implémenter la méthode push(element: T), qui augmente la taille de la pile et stocke l'élément.

• De même, la méthode pop():T est implémentée pour supprimer et renvoyer l'élément supérieur de la pile tout en réduisant sa taille.

• peek() : La méthode T permet de récupérer l'élément supérieur sans le supprimer.

• De plus, la méthode isEmpty(): boolean vérifie si la pile est vide, tandis que size(): number renvoie le nombre d'éléments actuellement dans la pile.

Exemple

import java.util.ArrayList;
import java.util.EmptyStackException;
import java.util.List;

public class Stack<T> {
   private List<T> stack;

   public Stack() {
      stack = new ArrayList<>();
   }

   public void push(T element) {
      stack.add(element);
   }

   public T pop() {
      if (isEmpty()) {
         throw new EmptyStackException();
      }
      return stack.remove(stack.size() - 1);
   }

   public T peek() {
      if (isEmpty()) {
         throw new EmptyStackException();
      }
      return stack.get(stack.size() - 1);
   }

   public boolean isEmpty() {
      return stack.isEmpty();
   }

   public int size() {
      return stack.size();
   }

   public void clear() {
      stack.clear();
   }

   public static void main(String[] args) {
      Stack<Integer> stack = new Stack<>();

      stack.push(1);
      stack.push(2);
      stack.push(3);

      System.out.println("Stack size: " + stack.size());
      System.out.println("Top element: " + stack.peek());

      while (!stack.isEmpty()) {
         System.out.println("Popped element: " + stack.pop());
      }
   }
}

Sortie

Stack size: 3
Top element: 3
Popped element: 3
Popped element: 2
Popped element: 1

Conclusion

En résumé, l'utilisation de tableaux et de génériques pour implémenter des piles en Java présente les avantages de la généralité et de la sécurité des types. En incorporant des génériques, les développeurs peuvent créer une classe générique appelée « Stack » pouvant contenir des éléments de tout type, augmentant ainsi la flexibilité de l'implémentation. Cette approche garantit que la structure des données de la pile peut s'adapter à divers scénarios tout en conservant des contraintes de type strictes.

La classe stack utilise un tableau de type T[] pour stocker les éléments et une variable entière appelée "top" pour garder une trace de l'élément le plus haut. Il fournit des méthodes de base telles que push, pop, peek, isEmpty, etc. pour garantir des opérations de pile efficaces.

Les développeurs peuvent tirer parti de cette implémentation pour créer des piles personnalisées pour des types spécifiques tout en bénéficiant des avantages de la sécurité des types. Des structures de données de pile robustes et efficaces peuvent être implémentées en Java en tirant parti des tableaux et des génériques.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!