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 tache 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>元素是否成對連續(xù)？<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:

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);

                // 檢查這對元素是否連續(xù)
                if (Math.abs(first - second) != 1) {
                    isPairwiseConsecutive = false;
                }
            }
        }

        // 恢復(fù)原始堆棧
        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("元素是否成對連續(xù)？ " + result);
    }
}

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!