Bagaimana untuk melaksanakan tindanan dalam Java menggunakan tatasusunan dan generik?

Java melaksanakan tindanan dengan memanfaatkan tatasusunan dan generik. Ini mewujudkan struktur data yang serba boleh dan boleh diguna semula yang beroperasi pada prinsip lepas masuk dahulu (LIFO). Mengikut prinsip ini, elemen ditambah dan dikeluarkan dari atas. Dengan menggunakan tatasusunan sebagai asas, ia memastikan peruntukan dan akses memori yang cekap. Selain itu, dengan menggabungkan generik, timbunan dapat menampung unsur-unsur pelbagai jenis, dengan itu meningkatkan kepelbagaiannya.

Pelaksanaan melibatkan takrifan kelas Tindanan yang mengandungi parameter jenis generik. Ia termasuk kaedah asas seperti push(), pop(), peek() dan isEmpty(). Pengendalian kes tepi, seperti limpahan tindanan dan aliran bawah, juga penting untuk memastikan kefungsian yang lancar. Pelaksanaan ini membolehkan pembangun membuat tindanan yang boleh menampung sebarang jenis elemen dalam Java.

Timbunan di Jawa

Di Java, tindanan ialah struktur data penting yang beroperasi pada prinsip keluar-masuk-dahulu (LIFO). Ia mewakili koleksi elemen yang mana elemen yang paling baru ditambah dialih keluar terlebih dahulu. Kelas tindanan dalam Java menyediakan pelbagai kaedah untuk memanipulasi elemen dengan cekap. Sebagai contoh, kaedah tolak membolehkan anda menambah elemen pada bahagian atas tindanan, manakala pop mengalih keluar dan mengembalikan elemen paling atas. Selain itu, intip membolehkan anda mendapatkan semula elemen teratas tanpa mengeluarkannya, dan isEmpty menyemak jika tindanan itu kosong.

import java.util.Stack;

Stack<Type> stack = new Stack<>();
stack.push(element); // Adds 'element' to the top of the stack
Type topElement = stack.pop(); // Removes and returns the top element
Type peekElement = stack.peek(); // Retrieves the top element without removing it
boolean isEmpty = stack.isEmpty(); // Checks if the stack is empty

Kaedah

Terdapat cara yang berbeza untuk melaksanakan tindanan dalam Java menggunakan tatasusunan dan generik, kami akan menyelidiki kedua-duanya:

• Gunakan tatasusunan untuk melaksanakan tindanan

• Gunakan generik untuk pelaksanaan tindanan

Gunakan tatasusunan untuk melaksanakan tindanan

Apabila melaksanakan tindanan dalam Java menggunakan tatasusunan, struktur data dicipta yang mengikut prinsip masuk-dahulu-keluar (LIFO). Dalam pendekatan ini, elemen disimpan dalam tatasusunan, dan pembolehubah teratas digunakan untuk menjejaki indeks yang mewakili elemen paling atas dalam timbunan.

Kelas tindanan biasanya mengandungi pelbagai kaedah. Ini termasuk push(), yang menambah elemen ke bahagian atas tindanan, pop(), yang mengalih keluar dan mendapatkan semula elemen teratas, pe-ek(), yang membolehkan anda melihat elemen teratas tanpa mengalih keluarnya, dan isEmpty ( ), yang menyemak sama ada tindanan kosong.

Algoritma

• Buat tatasusunan untuk menyimpan elemen timbunan.

• Memulakan pembolehubah bernama "atas" kepada -1, menunjukkan bahawa tindanan itu kosong.

• Tolak elemen pada tindanan:

• Semak sama ada tindanan sudah penuh (atas == tatasusunan.panjang - 1).

• Jika tindanan tidak penuh, naikkan pembolehubah "atas" sebanyak 1 dan tetapkan elemen kepada tatasusunan[atas].

• Pop elemen daripada timbunan:

• Semak sama ada tindanan kosong (atas == -1).

• Jika tindanan tidak kosong, dapatkan semula elemen dari tatasusunan[atas] dan kurangkan pembolehubah "atas" sebanyak 1.

Contoh

public class Stack {
   private int[] array;
   private int top;
   
   public Stack(int capacity) {
      array = new int[capacity];
      top = -1;
   }
   
   public void push(int element) {
      if (top == array.length - 1) {
         System.out.println("Stack is full. Cannot push element.");
      } else {
         top++;
         array[top] = element;
         System.out.println("Pushed element: " + element);
      }
   }
   
   public int pop() {
      if (top == -1) {
         System.out.println("Stack is empty. Cannot pop element.");
         return -1;
      } else {
         int poppedElement = array[top];
         top--;
         System.out.println("Popped element: " + poppedElement);
         return poppedElement;
      }
   }
   
   public int peek() {
      if (top == -1) {
         System.out.println("Stack is empty. No element to peek.");
         return -1;
      } else {
         System.out.println("Peeked element: " + array[top]);
         return array[top];
      }
   }
   
   public boolean isEmpty() {
      return (top == -1);
   }
   
   public static void main(String[] args) {
      Stack stack = new Stack(5);
      
      stack.push(10);
      stack.push(20);
      stack.push(30);
      
      stack.pop();
      
      stack.push(40);
      stack.push(50);
      
      stack.pop();
      stack.pop();
      stack.pop();
      stack.pop();
   }
}

Output

Pushed element: 10
Pushed element: 20
Pushed element: 30
Popped element: 30
Pushed element: 40
Pushed element: 50
Popped element: 50
Popped element: 40
Popped element: 20
Popped element: 10

Gunakan generik untuk pelaksanaan tindanan

Pelaksanaan tindanan dengan generik boleh digunakan sebagai struktur data biasa. Ia membolehkan elemen disimpan dan diambil semula dengan cara keluar masuk dahulu (LIFO), memberikan fleksibiliti dalam mengendalikan pelbagai jenis data. Dengan memanfaatkan bahan generik, tindanan yang boleh disesuaikan ini menjadi bekas yang cekap yang mampu menyimpan unsur apa-apa jenis, menjadikannya sangat serba boleh dan boleh digunakan semula.

Algoritma

• Buat kelas generik yang dipanggil Stack untuk menyimpan elemen dalam tindanan.

• Di dalam kelas Stack, terdapat tatasusunan peribadi atau senarai terpaut untuk menyimpan elemen ini.

• Timbunan dimulakan menggunakan pembina yang memperuntukkan memori yang diperlukan.

• Untuk menambah elemen pada bahagian atas tindanan, anda perlu melaksanakan kaedah push(elemen: T), yang meningkatkan saiz tindanan dan menyimpan elemen.

• Begitu juga, kaedah pop():T dilaksanakan untuk mengalih keluar dan mengembalikan elemen atas daripada tindanan sambil mengurangkan saiznya.

• peek(): Kaedah T membenarkan mendapatkan semula elemen teratas tanpa mengalihkannya.

• Selain itu, isEmpty(): kaedah boolean menyemak sama ada tindanan kosong, manakala saiz(): nombor mengembalikan bilangan elemen yang ada dalam tindanan pada masa ini.

Contoh

import java.util.ArrayList;
import java.util.EmptyStackException;
import java.util.List;

public class Stack<T> {
   private List<T> stack;

   public Stack() {
      stack = new ArrayList<>();
   }

   public void push(T element) {
      stack.add(element);
   }

   public T pop() {
      if (isEmpty()) {
         throw new EmptyStackException();
      }
      return stack.remove(stack.size() - 1);
   }

   public T peek() {
      if (isEmpty()) {
         throw new EmptyStackException();
      }
      return stack.get(stack.size() - 1);
   }

   public boolean isEmpty() {
      return stack.isEmpty();
   }

   public int size() {
      return stack.size();
   }

   public void clear() {
      stack.clear();
   }

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

      stack.push(1);
      stack.push(2);
      stack.push(3);

      System.out.println("Stack size: " + stack.size());
      System.out.println("Top element: " + stack.peek());

      while (!stack.isEmpty()) {
         System.out.println("Popped element: " + stack.pop());
      }
   }
}

Output

Stack size: 3
Top element: 3
Popped element: 3
Popped element: 2
Popped element: 1

KESIMPULAN

Ringkasnya, menggunakan tatasusunan dan generik untuk melaksanakan tindanan dalam Java mempunyai kelebihan serba boleh dan keselamatan jenis. Dengan menggabungkan generik, pembangun boleh mencipta kelas generik yang dipanggil "Timbunan" yang boleh memuatkan unsur apa-apa jenis, dengan itu meningkatkan fleksibiliti pelaksanaan. Pendekatan ini memastikan bahawa struktur data tindanan boleh menyesuaikan diri dengan pelbagai senario sambil mengekalkan kekangan jenis yang ketat.

Kelas tindanan menggunakan tatasusunan jenis T[] untuk menyimpan elemen dan pembolehubah integer dipanggil "atas" untuk menjejaki elemen paling atas. Ia menyediakan kaedah asas seperti push, pop, peek, isEmpty, dll. untuk memastikan operasi tindanan yang cekap.

Pembangun boleh memanfaatkan pelaksanaan ini untuk mencipta tindanan tersuai untuk jenis tertentu sambil mendapat manfaat daripada kelebihan keselamatan jenis. Struktur data tindanan yang teguh dan cekap boleh dilaksanakan di Java dengan memanfaatkan tatasusunan dan generik.

Atas ialah kandungan terperinci Bagaimana untuk melaksanakan tindanan dalam Java menggunakan tatasusunan dan generik?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!