Vérifiez si les éléments de pile sont par paire consécutifs en Java

La pile

est une structure de données de base en informatique et est généralement utilisée pour son attribut dernier-in-premier-out (LIFO) . Lorsque vous utilisez la pile, vous pouvez rencontrer un problème intéressant, c'est-à-dire pour vérifier si les éléments de la pile sont en paires continues. Dans cet article, nous apprendrons à résoudre ce problème à l'aide de Java pour garantir que la solution est efficace et claire.

Instruction Problème

Compte tenu d'une pile entière, la tâche consiste à déterminer si les éléments de la pile sont en paires continues. Si la différence entre deux éléments est exactement 1, elles sont considérées comme continues.

Entrez

<code>4, 5, 2, 3, 10, 11</code>

sortie

<code>元素是否成对连续？<br>true</code>

Étape pour vérifier si les éléments de pile sont appariés et continue

Voici des étapes pour vérifier si les éléments de pile sont appariés et continus:

• Vérifier la taille de la pile: Si le nombre d'éléments sur la pile est impair, le dernier élément ne sera pas apparié, il doit donc être ignoré pour l'inspection par paire.
• Vérification basée sur la paire: Boucle à travers la pile, éclatez les éléments par paires et vérifiez si elles sont continues.
• Restaurer la pile: Après avoir effectué un chèque, la pile doit être restaurée à son état d'origine.

Programme Java utilisé pour vérifier si les éléments de pile sont en paires et contigu

Ce qui suit est un programme en Java qui vérifie si les éléments de pile sont en paires et contiguës:

<code class="language-java">import java.util.Stack;

public class PairwiseConsecutiveChecker {
    public static boolean areElementsPairwiseConsecutive(Stack<integer> stack) {
        // 基本情况：如果堆栈为空或只有一个元素，则返回 true
        if (stack.isEmpty() || stack.size() == 1) {
            return true;
        }

        // 使用临时堆栈在检查时保存元素
        Stack<integer> tempStack = new Stack<>();
        boolean isPairwiseConsecutive = true;

        // 成对处理堆栈元素
        while (!stack.isEmpty()) {
            int first = stack.pop();
            tempStack.push(first);

            if (!stack.isEmpty()) {
                int second = stack.pop();
                tempStack.push(second);

                // 检查这对元素是否连续
                if (Math.abs(first - second) != 1) {
                    isPairwiseConsecutive = false;
                }
            }
        }

        // 恢复原始堆栈
        while (!tempStack.isEmpty()) {
            stack.push(tempStack.pop());
        }

        return isPairwiseConsecutive;
    }

    public static void main(String[] args) {
        Stack<integer> stack = new Stack<>();
        stack.push(4);
        stack.push(5);
        stack.push(2);
        stack.push(3);
        stack.push(10);
        stack.push(11);

        boolean result = areElementsPairwiseConsecutive(stack);

        System.out.println("元素是否成对连续？ " + result);
    }
}</integer></integer></integer></code>

Explication

Restaurer la pile: Puisque nous avons modifié la pile lors de la vérification de la droite, il est très important de le restaurer à son état d'origine une fois le chèque terminé. Cela garantit que la pile reste inchangée pour toute opération ultérieure.

Case de bord: Cette fonction gère les cas Edge, tels qu'une pile vide ou une pile avec un seul élément, retournant vrai car ces cas satisfont de manière insignifiante.

Complexité temporelle: La complexité temporelle de cette méthode est o (n) , où n est le nombre d'éléments dans la pile. En effet, nous ne traversons la pile qu'une seule fois, faisant éclater et pressant des éléments au besoin.

Complexité de l'espace: Parce que la pile temporaire est utilisée, la complexité de l'espace est également o (n) .

Conclusion

Cette solution fournit un moyen efficace de vérifier si les éléments de la pile sont en paires continues. La clé consiste à traiter la pile par paires et à vous assurer que la pile est restaurée à son état d'origine après l'opération. Cette approche maintient l'intégrité de la pile tout en fournissant une solution claire et efficace.

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!