Programme Java pour compter tous les éléments de pile

Ce tutoriel introduira plusieurs méthodes pour calculer le nombre d'éléments dans la pile Java. En Java, la pile est une structure de données de base qui suit le dernier principe de premier out (LIFO), ce qui signifie que les éléments récemment ajoutés à la pile seront accessibles en premier.

Les applications pratiques de la pile comprennent la gestion des appels de fonction, l'évaluation de l'expression, etc. Dans ces scénarios, nous devrons peut-être calculer le nombre d'éléments dans la pile. Par exemple, lorsque vous utilisez la pile pour la gestion des appels de fonction, vous devez calculer le nombre total d'appels de fonctions;

Nous explorerons trois façons de calculer le nombre d'éléments dans la pile:

Utiliser
• Méthodes Stack.size()
Utiliser
• boucle (méthode d'itération) for
Utiliser la méthode récursive

Utiliser

Méthodes Stack.size()

La première méthode pour calculer le nombre d'éléments dans la pile consiste à utiliser la méthode

. Il peut aider à trouver la taille de la pile, ce qui équivaut au nombre total d'éléments dans la pile. Stack.size()

grammaire

La syntaxe suivante peut être utilisée en Java en utilisant la méthode

: Stack.size()

s1.size();

Dans la syntaxe ci-dessus, "S1" est une structure de données de pile contenant des éléments tels que les nombres, les chaînes et les booléens.

Paramètres

La méthode

n'accepte aucun paramètre. Stack.size()

Valeur de retour

La méthode

renvoie le nombre total d'éléments dans la pile. Stack.size()

Exemple

Dans le code suivant, nous définissons la pile "S1". Après cela, nous insérons 3 entiers dans la pile. Lorsque nous utilisons la méthode

avec la pile, il renvoie "3" comme sortie, indiquant le nombre total d'éléments dans la pile. size()

import java.util.Stack;

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

        // 将元素压入栈
        s1.push(1);
        s1.push(2);
        s1.push(3);

        // 使用size()方法获取元素数量
        int count = s1.size();

        // 打印元素数量
        System.out.println("栈中元素数量：" + count);
    }
}

sortie

<code>栈中元素数量：3</code>

Utiliser

boucle (méthode d'itération) for

Maintenant, regardons la deuxième façon de calculer le nombre d'éléments dans la pile. Dans cette méthode, nous traverserons chaque élément de la pile à l'aide de

et calculerons le nombre total d'éléments dans la pile. for

grammaire

Le nombre total d'éléments dans la pile peut être calculé en utilisant

en utilisant la syntaxe suivante: for

for (Integer element : s1) {
     count++;
}

Dans la syntaxe ci-dessus, "S1" est une pile, et nous itèrent sur les éléments de la pile "S1". Dans le corps de la boucle, nous incrémentons la valeur de la variable "Count" de 1, qui stocke le nombre d'éléments dans la pile.

Exemple

Dans l'exemple suivant, nous parcourons chaque élément de la pile en utilisant

et incrément la valeur de la variable "Count" dans chaque itération. Après cela, nous imprimons la valeur de la variable "Count", qui est le nombre d'éléments dans la pile. for

import java.util.Stack;

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

        // 将元素压入栈
        s1.push(1);
        s1.push(2);
        s1.push(3);

        // 使用迭代计算元素数量
        int count = 0;
        for (Integer element : s1) {
            count++;
        }

        // 打印元素数量
        System.out.println("栈中元素数量：" + count);
    }
}

sortie

<code>栈中元素数量：3</code>

Utiliser la méthode récursive

La troisième façon de calculer tous les éléments de pile consiste à utiliser la récursivité. Dans cette approche, nous allons traverser récursivement chaque élément de la pile et suivre le nombre total d'éléments dans la pile.

grammaire

Tous les éléments de pile peuvent être calculés en utilisant la méthode récursive à l'aide de la syntaxe suivante:

if (s1.isEmpty()) {
    return 0;
}

// 移除顶部元素并计算其余元素
Integer element = s1.pop();
int count = 1 + countElements(s1);

// 将元素压回以恢复栈
s1.push(element);

Dans la syntaxe ci-dessus, nous suivons les étapes suivantes:

1. Si la pile est vide, renvoyez "0", indiquant qu'il n'y a pas d'éléments dans la pile.
2. Supprimer les éléments de la pile car nous calculerons le nombre d'occurrences de l'élément actuel à l'étape suivante.
3. Passez un appel récursif à la pile mise à jour, ajoutez sa valeur de résultat à "1" et stockez-la dans la variable "Count". Ici, nous ajoutons "1" à l'élément supprimé précédemment.
4. Ensuite, poussez à nouveau "élément" dans la pile pour garder l'état de pile inchangé.

Exemple

Dans cet exemple, nous utilisons une méthode récursive pour calculer le nombre d'éléments dans la pile.

s1.size();

sortie

import java.util.Stack;

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

        // 将元素压入栈
        s1.push(1);
        s1.push(2);
        s1.push(3);

        // 使用size()方法获取元素数量
        int count = s1.size();

        // 打印元素数量
        System.out.println("栈中元素数量：" + count);
    }
}

Conclusion

Nous explorons trois méthodes pour calculer le nombre total d'éléments dans la pile. La première méthode utilise la méthode Stack.size(), qui est simple et directe. La deuxième méthode utilise une boucle for pour calculer les éléments de pile, ce qui est légèrement plus compliqué que la première méthode. La troisième méthode utilise la récursivité pour calculer les éléments de pile, qui peuvent être plus compliqués pour les débutants.

Si vous avez besoin d'effectuer certaines opérations sur chaque élément de la pile lors du calcul des éléments de pile, vous devez utiliser la deuxième méthode.

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!