Java -Programm, um die oberen und unteren Elemente eines bestimmten Stacks zu finden

In diesem Tutorial wird erklärt, wie man Java verwendet, um die oberen und unteren Elemente eines bestimmten Stapels zu finden.

Der

Stack repräsentiert einen linearen Datensatz, der dem zuletzt zuletzt im ersten Out (LIFO) -Prinzip folgt, sodass Elemente an derselben Stelle hinzugefügt und entfernt werden. Wir werden weiter zwei Möglichkeiten untersuchen, um die oberen und unteren Elemente eines bestimmten Stapels zu finden, d. H. Über und rekursiv .

Problemanweisung

Wir werden ein Stapelarray mit N -Elementen erhalten, und die Aufgabe besteht darin, die 1. und n -ten Elemente des Stapels zu finden, ohne es in irgendeiner Weise zu zerstören. Daher müssen wir die iterativen Methoden

und die rekursiven Methoden in unserem benutzerdefinierten Stapel verwenden, um sicherzustellen, dass der ursprüngliche Stapel unverändert bleibt.

Geben Sie 1

ein

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

Ausgabe 1

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

Geben Sie 2

ein

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

Ausgabe 2

Iterationsmethode, um obere und untere Elemente zu finden

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

Für die erste Methode definieren wir ein Array, das als Stapel verwendet wird, und definieren dann den Stapelvorgang, um das gewünschte Element nach der iterativen Methode abzurufen. Hier sind die Schritte, um die oberen und unteren Elemente eines bestimmten Stapels zu finden:

initialisieren Sie den Stapel mit einem

maxSize
• Wert gleich 6 und stellen Sie oben auf -1 ein (repräsentiert ein leeres Array). Drücken Sie die Elemente 5, 10, 15, 20, 25 und 30 durch Push () -Operation auf den Stapel, während der Top -Wert in StackArray [Top] erhöht wird.
• Überprüfen Sie, ob der Stapel leer ist. Verwenden Sie dann peek () , um das obere Element zu finden, indem Sie StackArray [Top] zurückgeben, da oben bereits auf das letzte Element im Array eingestellt ist.
• Verwenden Sie schließlich die Funktion booth () , um das untere Element zu finden, das den Wert von StackArray [0] zurückgibt, dh das erste und Bottommost -Element im Stack -Array.
• Ausgabe der endgültigen oberen und unteren Werte.
Beispiel
Folgendes ist ein Java -Programm, das iterative Methoden verwendet, um die oberen und unteren Elemente eines bestimmten Stapels zu finden:

Ausgabe

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

Zeitkomplexität:

o (n) während der Stapelbildung (Druck), da jedes Element zum Ende des Arrays hinzugefügt wird und der Index jedes Mal bis zur Größe n erhöht wird. O (1) Während der Peek- und unteren Operationen, weil es Stackarray [Top] und Stackarray [0] zurückgibt.

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

Raumkomplexität: o (n), da wir Maxsize reparieren, um N -Elemente proportional zur Größe des Stapels zu speichern.

rekursive Methode, um obere und untere Elemente zu finden Bei diesem Ansatz werden wir die Rekursion verwenden, um die oberen und unteren Elemente im Stapel zu finden. Der Stapel wird unter Verwendung des Push () -Operation initialisiert und gebildet und extrahiert rekursiv die erforderlichen Elemente. Hier sind die Schritte, um die oberen und unteren Elemente eines bestimmten Stapels zu finden:

• initialisieren Sie den Stapel mit maxSize , der gleich 5 und oberen auf -1 entspricht.
• Überprüfen Sie, ob die Stapelgröße Maxsize nicht überschreitet. Verwenden Sie die Funktion push (), um jeden Ganzzahlwert auf den Stapel zu drücken, oben nach 1 zu erhöhen und den Wert in StackArray [Top] zu speichern.
• Verwenden Sie die rekursive Methode, um das untere Element zu ermitteln und den aktuellen Index auf den Top -Wert zu setzen. Wenn der Index 0 ist, dann StackArray [0] (unteres Element), sonst wird die Funktion rekursiv bezeichnet, wobei ein Index um 1 abnimmt.
• Finden Sie das obere Element mit einem Index auf 0. Wenn der aktuelle Index dem Top -Wert gleich ist, wird in dem Grundfall Stackarray [Top] zurückgegeben. Andernfalls wird die Funktion als rekursiv unter Verwendung eines durch 1 erhöhten Index bezeichnet.
• druckt rekursiv alle Elemente in StackArray [] , der Grundfall ist, dass der Index, wenn der Index weniger als 0 ist, die Rekursion gestoppt wird. Rufen Sie ansonsten die Funktion auf und drucken Sie den Ganzzahlwert rekursiv mit einem durch 1 abnehmenden Index.
• rufen Sie die Hauptfunktion auf und drucken Sie die oberen und unteren Elemente sowie den gesamten Stapel.

Beispiel

Folgendes ist ein Java -Programm, das eine rekursive Methode verwendet, um die oberen und unteren Elemente eines bestimmten Stacks zu finden:

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

Ausgabe

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

Zeitkomplexität: Gesamt ist O (n), da ein Element o (1) in der Push () -Operation während der Stapelbildung von Größe n verbringt. Im schlimmsten Fall kosten rekursive Betriebsvorgänge O (n).

räumliche Komplexität: Aufgrund des rekursiven Anrufstapels ist rekursiv o (n). Das Array selbst verwendet auch O (n), um N -Elemente zu speichern.

Schlussfolgerung

Kurz gesagt, beide Methoden sind auf ihre jeweiligen Fälle anwendbar, in denen die Direktarray -Methode einen konstanten Zeitzugriff auf Stapelelemente und ihre einfache interaktive Implementierung bietet. Andererseits bieten rekursive Methoden eine rekursive Perspektive auf Stapeloperationen, wodurch sie allgemeiner werden und algorithmische Methoden hervorheben. Das Verständnis dieser beiden Methoden gibt Ihnen die Grundlagen des Stapels und wann die beiden Methoden verwendet werden.

Das obige ist der detaillierte Inhalt vonJava -Programm, um die oberen und unteren Elemente eines bestimmten Stacks zu finden. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!