Program Java untuk mengira semua elemen timbunan

Tutorial ini akan memperkenalkan beberapa kaedah untuk mengira bilangan elemen dalam timbunan Java. Di Java, timbunan adalah struktur data asas yang mengikuti prinsip terakhir dalam (LIFO) yang terakhir, yang bermaksud bahawa unsur -unsur baru -baru ini ditambah ke timbunan akan diakses terlebih dahulu.

Aplikasi praktikal timbunan termasuk pengurusan panggilan fungsi, penilaian ekspresi, dll. Dalam senario ini, kita mungkin perlu mengira bilangan elemen dalam timbunan. Sebagai contoh, apabila menggunakan timbunan untuk pengurusan panggilan fungsi, anda perlu mengira jumlah panggilan fungsi;

kami akan meneroka tiga cara untuk mengira bilangan elemen dalam timbunan:

Gunakan

Kaedah
• Stack.size() Gunakan
gelung (kaedah lelaran)
• for Gunakan kaedah rekursif
Gunakan

Kaedah

Stack.size() Kaedah pertama untuk mengira bilangan elemen dalam timbunan adalah dengan menggunakan kaedah

. Ia dapat membantu mencari saiz timbunan, yang bersamaan dengan jumlah elemen dalam timbunan.

Stack.size() Tatabahasa

sintaks berikut boleh digunakan di Java menggunakan kaedah

:

Stack.size()

Dalam sintaks di atas, "S1" adalah struktur data stack yang mengandungi unsur -unsur seperti nombor, rentetan, dan boolean.

s1.size();

Parameter

Kaedah

tidak menerima sebarang parameter.

Stack.size() nilai pulangan

Kaedah

mengembalikan jumlah elemen dalam timbunan.

Stack.size() Contoh

Dalam kod berikut, kami menentukan timbunan "S1". Selepas itu, kami memasukkan 3 bilangan bulat ke dalam timbunan. Apabila kita menggunakan kaedah

dengan timbunan, ia mengembalikan "3" sebagai output, menunjukkan jumlah elemen dalam timbunan.

size()

output

import java.util.Stack;

public class StackExample {
    public static void main(String[] args) {
        Stack<Integer> s1 = new Stack<>();

        // 将元素压入栈
        s1.push(1);
        s1.push(2);
        s1.push(3);

        // 使用size()方法获取元素数量
        int count = s1.size();

        // 打印元素数量
        System.out.println("栈中元素数量：" + count);
    }
}

Gunakan

<code>栈中元素数量：3</code>

gelung (kaedah lelaran)

for Sekarang, mari kita lihat cara kedua untuk mengira bilangan elemen dalam timbunan. Dalam kaedah ini, kami akan melengkung melalui setiap elemen timbunan menggunakan

dan mengira jumlah elemen dalam timbunan.

for Tatabahasa

Jumlah elemen dalam timbunan boleh dikira menggunakan

menggunakan sintaks berikut:

for

Dalam sintaks di atas, "S1" adalah timbunan, dan kami melelehkan unsur -unsur timbunan "S1". Dalam badan gelung, kita meningkatkan nilai pembolehubah "kiraan" dengan 1, yang menyimpan bilangan elemen dalam timbunan.

for (Integer element : s1) {
     count++;
}

Contoh

Dalam contoh berikut, kami gelung melalui setiap elemen timbunan menggunakan

dan meningkatkan nilai pembolehubah "kiraan" dalam setiap lelaran. Selepas itu, kami mencetak nilai pembolehubah "kiraan", yang merupakan bilangan elemen dalam timbunan.

for

output

import java.util.Stack;

public class StackCountIterative {
    public static void main(String[] args) {
        Stack<Integer> s1 = new Stack<>();

        // 将元素压入栈
        s1.push(1);
        s1.push(2);
        s1.push(3);

        // 使用迭代计算元素数量
        int count = 0;
        for (Integer element : s1) {
            count++;
        }

        // 打印元素数量
        System.out.println("栈中元素数量：" + count);
    }
}

Gunakan kaedah rekursif

<code>栈中元素数量：3</code>

Cara ketiga untuk mengira semua elemen timbunan adalah dengan menggunakan rekursi. Dalam pendekatan ini, kami akan secara rekursif melintasi setiap elemen timbunan dan menjejaki jumlah elemen dalam timbunan.

Tatabahasa

semua elemen timbunan boleh dikira menggunakan kaedah rekursif menggunakan sintaks berikut:

Dalam sintaks di atas, kami mengikuti langkah -langkah berikut:

if (s1.isEmpty()) {
    return 0;
}

// 移除顶部元素并计算其余元素
Integer element = s1.pop();
int count = 1 + countElements(s1);

// 将元素压回以恢复栈
s1.push(element);

1. Jika timbunan kosong, kembali "0", menunjukkan bahawa tiada unsur dalam timbunan.
2. Keluarkan elemen dalam timbunan kerana kita akan mengira bilangan kejadian elemen semasa dalam langkah seterusnya.
3. Buat panggilan rekursif ke timbunan yang dikemas kini, tambahkan nilai hasilnya kepada "1" dan simpan dalam pembolehubah "kiraan". Di sini kita menambah "1" ke elemen yang telah dikeluarkan sebelumnya.
4. Seterusnya, tolak "elemen" ke dalam timbunan sekali lagi untuk memastikan keadaan timbunan tidak berubah.

Contoh

Dalam contoh ini, kami menggunakan kaedah rekursif untuk mengira bilangan elemen dalam timbunan.

s1.size();

output

import java.util.Stack;

public class StackExample {
    public static void main(String[] args) {
        Stack<Integer> s1 = new Stack<>();

        // 将元素压入栈
        s1.push(1);
        s1.push(2);
        s1.push(3);

        // 使用size()方法获取元素数量
        int count = s1.size();

        // 打印元素数量
        System.out.println("栈中元素数量：" + count);
    }
}

Kesimpulan

Kami meneroka tiga kaedah untuk mengira jumlah elemen dalam timbunan. Kaedah pertama menggunakan kaedah Stack.size(), yang mudah dan langsung. Kaedah kedua menggunakan gelung for untuk mengira elemen timbunan, yang sedikit lebih rumit daripada kaedah pertama. Kaedah ketiga menggunakan rekursi untuk mengira elemen timbunan, yang mungkin lebih rumit untuk pemula.

Jika anda perlu melakukan operasi tertentu pada setiap elemen timbunan semasa mengira elemen timbunan, anda harus menggunakan kaedah kedua.

Atas ialah kandungan terperinci Program Java untuk mengira semua elemen timbunan. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!