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()方法獲取元素?cái)?shù)量
        int count = s1.size();

        // 打印元素?cái)?shù)量
        System.out.println("棧中元素?cái)?shù)量：" + count);
    }
}

Gunakan

<code>棧中元素?cái)?shù)量：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);

        // 使用迭代計(jì)算元素?cái)?shù)量
        int count = 0;
        for (Integer element : s1) {
            count++;
        }

        // 打印元素?cái)?shù)量
        System.out.println("棧中元素?cái)?shù)量：" + count);
    }
}

Gunakan kaedah rekursif

<code>棧中元素?cái)?shù)量：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;
}

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

// 將元素壓回以恢復(fù)棧
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()方法獲取元素?cái)?shù)量
        int count = s1.size();

        // 打印元素?cái)?shù)量
        System.out.println("棧中元素?cái)?shù)量：" + 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!