Stack adalah struktur data linear yang membolehkan operasi hanya pada satu hujung, yang dipanggil bahagian atas. Operasi utama termasuk:

tolak (push)
• : Tambah elemen ke bahagian atas timbunan.
pop (pop)
• : Menghapuskan dan kembali ke elemen atas timbunan.
Lihat (mengintip)
• : Lihat elemen atas timbunan tanpa mengeluarkannya.
isEmpty (isEmpty)
• : periksa sama ada timbunan kosong.
Pernyataan Masalah

dan

min max

import java.util.Stack;

public class MaxMinInStack {
    public static void main(String[] args) {
        Stack<Integer> stack = new Stack<>();
        stack.push(10);
        stack.push(20);
        stack.push(30);
        stack.push(5);
        stack.push(15);

        int[] result = findMaxMin(stack);
        System.out.println("最大元素: " + result[0]);
        System.out.println("最小元素: " + result[1]);
    }

    public static int[] findMaxMin(Stack<Integer> stack) {
        if (stack.isEmpty()) {
            throw new IllegalArgumentException("棧為空");
        }

        int max = Integer.MIN_VALUE;
        int min = Integer.MAX_VALUE;

        for (Integer element : stack) {
            if (element > max) {
                max = element;
            }
            if (element < min) {
                min = element;
            }
        }
        return new int[]{max, min};
    }
}

di sini, kami melintasi timbunan dengan menggunakan operasi pop timbul dan mengemas kini nilai minimum dan maksimum seperti yang diperlukan. Tumpukan tambahan sementara menjimatkan unsur -unsur dan kemudian mengembalikan unsur -unsur ini ke timbunan asal.

import java.util.Stack;

public class MaxMinInStack {
    public static void main(String[] args) {
        Stack<Integer> stack = new Stack<>();
        stack.push(10);
        stack.push(20);
        stack.push(30);
        stack.push(5);
        stack.push(15);

        int[] result = findMaxMinWithAuxiliaryStack(stack);
        System.out.println("最大元素: " + result[0]);
        System.out.println("最小元素: " + result[1]);
    }

    public static int[] findMaxMinWithAuxiliaryStack(Stack<Integer> stack) {
        if (stack.isEmpty()) {
            throw new IllegalArgumentException("棧為空");
        }

        Stack<Integer> tempStack = new Stack<>();
        int max = stack.peek();
        int min = stack.peek();

        while (!stack.isEmpty()) {
            int current = stack.pop();
            if (current > max) {
                max = current;
            }
            if (current < min) {
                min = current;
            }
            tempStack.push(current);
        }

        while (!tempStack.isEmpty()) {
            stack.push(tempStack.pop());
        }

        return new int[]{max, min};
    }
}

Kaedah ini menggunakan dua susunan tambahan, satu untuk mengingati elemen terbesar (

) dan yang lain untuk mengingati elemen terkecil (). Setiap kali elemen baru memasuki timbunan utama, jika ia menjadikan nilai maksimum atau minimum lebih besar, kami juga memasukkannya ke dalam

. maxStack minStack maxStack minStack

import java.util.Stack;

public class MaxMinInStack {
    // ... (main method remains the same) ...

    public static int[] findMaxMinWithTwoStacks(Stack<Integer> stack) {
        Stack<Integer> maxStack = new Stack<>();
        Stack<Integer> minStack = new Stack<>();

        while (!stack.isEmpty()) {
            int current = stack.pop();
            if (maxStack.isEmpty() || current >= maxStack.peek()) {
                maxStack.push(current);
            }
            if (minStack.isEmpty() || current <= minStack.peek()) {
                minStack.push(current);
            }
        }
        return new int[]{maxStack.peek(), minStack.peek()};
    }
}

Gunakan struktur timbunan yang diubah suai

import java.util.Stack;

public class MaxMinInStack {
    static class StackNode {
        int value;
        int currentMax;
        int currentMin;

        StackNode(int value, int currentMax, int currentMin) {
            this.value = value;
            this.currentMax = currentMax;
            this.currentMin = currentMin;
        }
    }

    public static void main(String[] args) {
        Stack<StackNode> stack = new Stack<>();
        push(stack, 10);
        push(stack, 20);
        push(stack, 30);
        push(stack, 5);
        push(stack, 15);

        int[] result = findMaxMinWithModifiedStack(stack);
        System.out.println("最大元素: " + result[0]);
        System.out.println("最小元素: " + result[1]);
    }

    public static void push(Stack<StackNode> stack, int value) {
        int max = stack.isEmpty() ? value : Math.max(value, stack.peek().currentMax);
        int min = stack.isEmpty() ? value : Math.min(value, stack.peek().currentMin);
        stack.push(new StackNode(value, max, min));
    }

    public static int[] findMaxMinWithModifiedStack(Stack<StackNode> stack) {
        if (stack.isEmpty()) {
            throw new IllegalArgumentException("棧為空");
        }

        StackNode topNode = stack.peek();
        return new int[]{topNode.currentMax, topNode.currentMin};
    }
}

Kesimpulan

Setiap teknologi menyediakan cara khusus untuk menangani akses atau menyimpan item timbunan, yang menjadikannya sesuai untuk situasi tertentu berdasarkan batasan memori, keperluan prestasi, dan keperluan integriti data. Memahami dan memohon kaedah ini boleh membantu pemaju mengendalikan susunan dengan berkesan di Java, menjadikan aplikasi mereka paling sesuai untuk situasi tertentu.