Programme Java pour trouver les éléments supérieur et inférieur d'une pile donnée

Ce tutoriel expliquera comment utiliser Java pour trouver les éléments supérieurs et inférieurs d'une pile donnée.

La pile

représente un ensemble de données linéaire qui suit le principe Last in First Out (lifo) , donc des éléments sont ajoutés et supprimés au même endroit. Nous explorerons davantage deux façons de trouver les éléments supérieurs et inférieurs d'une pile donnée, c'est-à-dire itérer sur et récursivement .

Instruction Problème

Nous obtiendrons un tableau de pile contenant n éléments, et la tâche consiste à trouver les 1er et nième éléments de la pile sans le détruire de quelque manière que ce soit. Par conséquent, nous devons utiliser les

méthodes itératives et les méthodes récursives dans notre pile personnalisée pour garantir que la pile d'origine reste inchangée.

Entrez 1

<code>stack = [5, 10, 15, 20, 25, 30]</code>

Sortie 1

<code>堆栈中的顶部元素是 --> 30
堆栈中的底部元素是 --> 5</code>

Entrez 2

<code>stack = [1000, 2000, 3000, 4000, 5000]</code>

Sortie 2

<code>堆栈元素：5000 4000 3000 2000 1000
底部元素：1000
顶部元素：5000</code>

Méthode d'itération pour trouver les éléments supérieurs et inférieurs

Pour la première méthode, nous définirons un tableau utilisé comme pile, puis définirons l'opération de pile pour récupérer l'élément souhaité par la méthode itérative. Voici les étapes pour trouver les éléments supérieurs et inférieurs d'une pile donnée:

Initialisez la pile avec une valeur
• maxsize égale à 6 et réglez le dessus sur -1 (représente un tableau vide). Appuyez sur les éléments 5, 10, 15, 20, 25 et 30 sur l'opération de pile par push (), tout en augmentant la valeur supérieure dans stackArray [top]
.
• Vérifiez si la pile est vide. Ensuite, utilisez peek ()
pour trouver l'élément supérieur en retournant StackArray [en haut], car le haut est déjà défini sur le dernier élément du tableau.
• Enfin, utilisez la fonction inférieure ()
pour trouver l'élément inférieur, qui renvoie la valeur de StackArray [0], c'est-à-dire l'élément premier et bottommost dans le tableau de pile.
• Sortir les valeurs finales et inférieures finales.
• Exemple

Ce qui suit est un programme Java qui utilise des méthodes itératives pour trouver les éléments supérieurs et inférieurs d'une pile donnée:

sortie

<code class="language-java">class MyStack {
    private int maxSize;
    private int[] stackArray;
    private int top;
    // 使用MyStack构造函数初始化堆栈
    public MyStack(int size) {
        this.maxSize = size;
        this.stackArray = new int[maxSize];

        // 将Top变量初始化为-1，表示空堆栈
        this.top = -1;
    }
    // 将元素添加到stackArray中
    public void push(int value) {
        if (top < maxSize -1) {
            stackArray[++top] = value;
        } else {
            System.out.println("堆栈已满");
        }
    }
    // 使用peek()查找顶部元素
    public int peek() {
        if (top >= 0) {
            return stackArray[top];
        } else {
            System.out.println("堆栈为空。");
            return -1;
        }
    }
    // 使用bottom()查找堆栈数组中的底部元素（第一个添加的值）
    public int bottom() {
        if (top >= 0) {
            return stackArray[0];
        } else {
            System.out.println("堆栈为空。");
            return -1;
        }
    }
}
public class Main {
    public static void main(String[] args) {
        MyStack stack = new MyStack(6); // 创建大小为6的堆栈
        // 将元素压入堆栈
        stack.push(5);
        stack.push(10);
        stack.push(15);
        stack.push(20);
        stack.push(25);
        stack.push(30);
        // 检索顶部和底部元素
        int topElement = stack.peek();
        int bottomElement = stack.bottom();
        // 打印最终输出
        System.out.println("堆栈中的顶部元素是 --> " + topElement);
        System.out.println("堆栈中的底部元素是 --> " + bottomElement);
    }
}</code>

Complexité temporelle:

<code>堆栈中的顶部元素是 --> 30
堆栈中的底部元素是 --> 5</code>

o (n) pendant la formation de pile (pression), car chaque élément est ajouté à la fin du tableau, et l'indice est incrémenté de 1 à chaque fois jusqu'à la taille n. O (1) pendant les opérations de Peek et Bottom, car il renvoie StackArray [Top] et StackArray [0].

Complexité de l'espace:

o (n), car nous fixons maxsize pour stocker n éléments, proportionnelle à la taille de la pile.

Méthode récursive pour trouver les éléments supérieurs et inférieurs

Dans cette approche, nous utiliserons la récursivité pour trouver les éléments supérieur et inférieur de la pile. La pile est initialisée et formée à l'aide de l'opération push () et extrait récursivement les éléments requis. Voici les étapes pour trouver les éléments supérieurs et inférieurs d'une pile donnée:

• Initialisez la pile avec maxsize qui est égal à 5 ​​et supérieur à -1.
• Vérifiez si la taille de la pile ne dépasse pas MaxSize. Utilisez la fonction push () pour pousser chaque valeur entière sur la pile, incrément en haut de 1 et stocker la valeur dans stackArray [haut] .
• Utilisez la méthode récursive pour trouver l'élément inférieur et définissez l'index actuel sur la valeur supérieure. Ensuite, si l'index est 0, alors stackArray [0] (élément inférieur), sinon la fonction est appelée récursive avec un index décrémentant de 1.
• Trouvez l'élément supérieur avec un index défini sur 0. Dans le cas de base, si l'index actuel est égal à la valeur supérieure, alors stackArray [top] est renvoyé. Sinon, la fonction est appelée récursivement à l'aide d'un indice incrémenté de 1.
• imprime récursivement tous les éléments dans stackArray [] , le cas de base est que si l'index est inférieur à 0, la récursivité est arrêtée. Sinon, appelez la fonction et imprimez la valeur entière récursivement avec un index décrémenté de 1.
• Appelez la fonction principale et imprimez les éléments supérieurs et inférieurs ainsi que la pile entière.

Exemple

Ce qui suit est un programme Java qui utilise une méthode récursive pour trouver les éléments supérieurs et inférieurs d'une pile donnée:

<code>stack = [5, 10, 15, 20, 25, 30]</code>

sortie

<code>堆栈中的顶部元素是 --> 30
堆栈中的底部元素是 --> 5</code>

Complexité temporelle: Le total est O (n), car un élément dépense O (1) dans l'opération push () pendant la formation de pile de la taille n. Dans le pire des cas, les opérations récursives coûtent o (n).

Complexité spatiale: En raison de la pile d'appels récursive, récursivement est O (n). Le tableau lui-même utilise également O (n) pour stocker n éléments.

Conclusion

En bref, les deux méthodes sont applicables à leurs cas respectifs, où la méthode du tableau direct offre un accès à temps constant aux éléments de pile et sa simple implémentation interactive. D'un autre côté, les méthodes récursives fournissent une perspective récursive sur les opérations de pile, ce qui les rend plus généraux et mettant l'accent sur les méthodes algorithmiques. Comprendre ces deux méthodes vous donne les bases de la pile et quand utiliser l'une ou l'autre 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!