如何使用陣列和泛型在Java中實現堆疊？

Java 透過利用陣列和泛型來實作堆疊。這創建了一個多功能且可重複使用的資料結構，該結構按照後進先出（LIFO）的原則運作。按照這個原則，元素是從頂部新增和刪除的。透過利用數組作為基礎，它確保了高效的記憶體分配和存取。此外，透過合併泛型，堆疊能夠容納不同類型的元素，從而增強其多功能性。

此實作涉及包含泛型類型參數的 Stack 類別的定義。它包括基本方法，如push()、pop()、peek() 和isEmpty()。邊緣情況的處理（例如堆疊溢位和下溢）對於確保無縫功能也至關重要。此實作使開發人員能夠建立能夠容納 Java 中任何類型元素的堆疊。

Java 中的堆疊

在 Java 中，堆疊是一種重要的資料結構，它按照後進先出 (LIFO) 的原則運作。它表示元素的集合，其中最近添加的元素優先刪除。 Java 中的堆疊類別提供了多種有效操作元素的方法。例如，push 方法可讓您將元素新增至堆疊頂部，而 pop 則刪除並傳回最頂層的元素。此外，peek 使您能夠檢索頂部元素而不刪除它，並且 isEmpty 檢查堆疊是否為空。

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

方法

使用陣列和泛型在 Java 中實作堆疊有不同的方法，我們將深入研究這兩種方法：

• 使用陣列實作堆疊

• 使用泛型進行堆疊實現

使用陣列實作堆疊

當使用陣列在 Java 中實作堆疊時，會建立一個遵循後進先出 (LIFO) 原則的資料結構。在這種方法中，元素儲存在陣列中，而頂部變數用於追蹤表示堆疊中最頂層元素的索引。

堆疊類別通常包含多個方法。其中包括push()，它將元素添加到堆疊的頂部，pop()，用於刪除和檢索最上面的元素，pe-ek()，允許您查看最上面的元素而不刪除它，以及isEmpty ( )，它檢查堆疊是否為空。

演算法

• 建立一個陣列來儲存堆疊的元素。

• 將名為「top」的變數初始化為-1，表示堆疊為空。

• 將元素壓入堆疊：

• 檢查堆疊是否已滿（top == array.length - 1）。

• 如果堆疊未滿，則將「top」變數加 1 並將元素指派給 array[top]。

• 從堆疊中彈出一個元素：

• 檢查堆疊是否為空（top == -1）。

• 如果堆疊不為空，則從 array[top] 中檢索元素並將「top」變數減 1。

範例

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

輸出

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

使用泛型進行堆疊實現

具有泛型的堆疊實作可用作通用資料結構。它允許以後進先出 (LIFO) 方式儲存和檢索元素，從而提供處理各種資料類型的靈活性。透過利用泛型，這種適應性強的堆疊成為一個高效的容器，能夠容納任何類型的元素，使其具有極大的通用性和可重複使用性。

演算法

• 建立一個名為 Stack 的泛型類別來將元素儲存在堆疊中。

• #在Stack類別內部，有一個私有陣列或鍊錶來保存這些元素。

• 堆疊使用分配必要記憶體的建構函式進行初始化。

• 要將元素新增到堆疊頂部，需要實作 push(element: T) 方法，該方法會增加堆疊大小並儲存該元素。

• 類似地，實作了 pop():T 方法來從堆疊中刪除並傳回頂部元素，同時減少其大小。

• peek(): T 方法允許檢索頂部元素而不刪除它。

• 此外， isEmpty(): boolean 方法檢查堆疊是否為空，而 size(): number 傳回堆疊中目前有多少元素。

範例

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

輸出

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

結論

總之，在 Java 中使用陣列和泛型來實現堆疊具有通用性和類型安全性的優點。透過合併泛型，開發人員可以建立一個名為「Stack」的泛型類，它可以容納任何類型的元素，從而增強了實現的靈活性。這種方法確保堆疊資料結構能夠適應各種場景，同時保持嚴格的類型約束。

stack 類別使用 T[] 類型的陣列來儲存元素，並使用稱為「top」的整數變數來追蹤最頂層的元素。它提供了push、pop、peek、isEmpty等基本方法，確保高效的堆疊操作。

開發人員可以利用此實作為特定類型建立自訂堆疊，同時受益於類型安全的優勢。透過利用陣列和泛型，可以在 Java 中實現健壯且高效的堆疊資料結構。

以上是如何使用陣列和泛型在Java中實現堆疊？的詳細內容。更多資訊請關注PHP中文網其他相關文章！