xinyin025/hello-algo
1
0
Fork 0
mirror of https://github.com/krahets/hello-algo.git synced 2026-07-03 11:04:26 +00:00
Code Issues Packages Projects Releases Wiki Activity

build

Browse Source
This commit is contained in:
krahets
2025-10-17 05:33:23 +08:00
parent 9278f3c659
commit 68bb9afb16
113 changed files with 35936 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
ja/docs/chapter_stack_and_queue/deque.md
+1258
View File
File diff suppressed because it is too large Load Diff
ja/docs/chapter_stack_and_queue/index.md
+21
View File
@@ -0,0 +1,21 @@
---
comments: true
icon: material/stack-overflow
---
# 第 5 章   スタックとキュー
![スタックとキュー](../assets/covers/chapter_stack_and_queue.jpg){ class="cover-image" }
!!! abstract
スタックは積み重ねられた猫のようなもので、キューは一列に並んだ猫のようなものです。
それらはそれぞれ、後入先出（LIFO）と先入先出（FIFO）の論理関係を表しています。
## 章の内容
- [5.1   スタック](stack.md)
- [5.2   キュー](queue.md)
- [5.3   両端キュー](deque.md)
- [5.4   まとめ](summary.md)
ja/docs/chapter_stack_and_queue/queue.md
+931
View File
@@ -0,0 +1,931 @@
---
comments: true
---
# 5.2   キュー
<u>キュー</u>は、先入先出（FIFO）ルールに従う線形データ構造です。名前が示すように、キューは行列の現象をシミュレートし、新参者は列の後ろに並び、前の人が最初に列を離れます。
下図に示すように、キューの前面を「ヘッド」、後面を「テール」と呼びます。キューの後ろに要素を追加する操作を「エンキュー」、前から要素を削除する操作を「デキュー」と呼びます。
![キューの先入先出ルール](queue.assets/queue_operations.png){ class="animation-figure" }
<p align="center"> 図 5-4 &nbsp; キューの先入先出ルール </p>
## 5.2.1 &nbsp; キューの一般的な操作
キューの一般的な操作を下表に示します。メソッド名はプログラミング言語によって異なる場合があることに注意してください。ここでは、スタックで使用したのと同じ命名規則を使用します。
<p align="center"> 表 5-2 &nbsp; キュー操作の効率 </p>
<div class="center-table" markdown>
| メソッド名 | 説明 | 時間計算量 |
| ----------- | -------------------------------------- | --------------- |
| `push()` | 要素をエンキュー、テールに追加 | $O(1)$ |
| `pop()` | ヘッド要素をデキュー | $O(1)$ |
| `peek()` | ヘッド要素にアクセス | $O(1)$ |
</div>
プログラミング言語で用意されているキュークラスを直接使用できます：
=== "Python"
```python title="queue.py"
from collections import deque
# キューを初期化
# Pythonでは、一般的にdequeクラスをキューとして使用します
# queue.Queue()は純粋なキュークラスですが、使いにくいため推奨されません
que: deque[int] = deque()
# 要素をエンキュー
que.append(1)
que.append(3)
que.append(2)
que.append(5)
que.append(4)
# 最初の要素にアクセス
front: int = que[0]
# 要素をデキュー
pop: int = que.popleft()
# キューの長さを取得
size: int = len(que)
# キューが空かどうかチェック
is_empty: bool = len(que) == 0
```
=== "C++"
```cpp title="queue.cpp"
/* キューを初期化 */
queue<int> queue;
/* 要素をエンキュー */
queue.push(1);
queue.push(3);
queue.push(2);
queue.push(5);
queue.push(4);
/* 最初の要素にアクセス */
int front = queue.front();
/* 要素をデキュー */
queue.pop();
/* キューの長さを取得 */
int size = queue.size();
/* キューが空かどうかチェック */
bool empty = queue.empty();
```
=== "Java"
```java title="queue.java"
/* キューを初期化 */
Queue<Integer> queue = new LinkedList<>();
/* 要素をエンキュー */
queue.offer(1);
queue.offer(3);
queue.offer(2);
queue.offer(5);
queue.offer(4);
/* 最初の要素にアクセス */
int peek = queue.peek();
/* 要素をデキュー */
int pop = queue.poll();
/* キューの長さを取得 */
int size = queue.size();
/* キューが空かどうかチェック */
boolean isEmpty = queue.isEmpty();
```
=== "C#"
```csharp title="queue.cs"
/* キューを初期化 */
Queue<int> queue = new();
/* 要素をエンキュー */
queue.Enqueue(1);
queue.Enqueue(3);
queue.Enqueue(2);
queue.Enqueue(5);
queue.Enqueue(4);
/* 最初の要素にアクセス */
int peek = queue.Peek();
/* 要素をデキュー */
int pop = queue.Dequeue();
/* キューの長さを取得 */
int size = queue.Count;
/* キューが空かどうかチェック */
bool isEmpty = queue.Count == 0;
```
=== "Go"
```go title="queue_test.go"
/* キューを初期化 */
// Goでは、listをキューとして使用
queue := list.New()
/* 要素をエンキュー */
queue.PushBack(1)
queue.PushBack(3)
queue.PushBack(2)
queue.PushBack(5)
queue.PushBack(4)
/* 最初の要素にアクセス */
peek := queue.Front()
/* 要素をデキュー */
pop := queue.Front()
queue.Remove(pop)
/* キューの長さを取得 */
size := queue.Len()
/* キューが空かどうかチェック */
isEmpty := queue.Len() == 0
```
=== "Swift"
```swift title="queue.swift"
/* キューを初期化 */
// Swiftには組み込みのキュークラスがないため、Arrayをキューとして使用
var queue: [Int] = []
/* 要素をエンキュー */
queue.append(1)
queue.append(3)
queue.append(2)
queue.append(5)
queue.append(4)
/* 最初の要素にアクセス */
let peek = queue.first!
/* 要素をデキュー */
// 配列なので、removeFirstの計算量はO(n)
let pool = queue.removeFirst()
/* キューの長さを取得 */
let size = queue.count
/* キューが空かどうかチェック */
let isEmpty = queue.isEmpty
```
=== "JS"
```javascript title="queue.js"
/* キューを初期化 */
// JavaScriptには組み込みのキューがないため、Arrayをキューとして使用
const queue = [];
/* 要素をエンキュー */
queue.push(1);
queue.push(3);
queue.push(2);
queue.push(5);
queue.push(4);
/* 最初の要素にアクセス */
const peek = queue[0];
/* 要素をデキュー */
// 基礎構造が配列なので、shift()メソッドの時間計算量はO(n)
const pop = queue.shift();
/* キューの長さを取得 */
const size = queue.length;
/* キューが空かどうかチェック */
const empty = queue.length === 0;
```
=== "TS"
```typescript title="queue.ts"
/* キューを初期化 */
// TypeScriptには組み込みのキューがないため、Arrayをキューとして使用
const queue: number[] = [];
/* 要素をエンキュー */
queue.push(1);
queue.push(3);
queue.push(2);
queue.push(5);
queue.push(4);
/* 最初の要素にアクセス */
const peek = queue[0];
/* 要素をデキュー */
// 基礎構造が配列なので、shift()メソッドの時間計算量はO(n)
const pop = queue.shift();
/* キューの長さを取得 */
const size = queue.length;
/* キューが空かどうかチェック */
const empty = queue.length === 0;
```
=== "Dart"
```dart title="queue.dart"
/* キューを初期化 */
// DartのQueueクラスは双方向キューですが、キューとして使用できます
Queue<int> queue = Queue();
/* 要素をエンキュー */
queue.add(1);
queue.add(3);
queue.add(2);
queue.add(5);
queue.add(4);
/* 最初の要素にアクセス */
int peek = queue.first;
/* 要素をデキュー */
int pop = queue.removeFirst();
/* キューの長さを取得 */
int size = queue.length;
/* キューが空かどうかチェック */
bool isEmpty = queue.isEmpty;
```
=== "Rust"
```rust title="queue.rs"
/* 双方向キューを初期化 */
// Rustでは、双方向キューを通常のキューとして使用
let mut deque: VecDeque<u32> = VecDeque::new();
/* 要素をエンキュー */
deque.push_back(1);
deque.push_back(3);
deque.push_back(2);
deque.push_back(5);
deque.push_back(4);
/* 最初の要素にアクセス */
if let Some(front) = deque.front() {
}
/* 要素をデキュー */
if let Some(pop) = deque.pop_front() {
}
/* キューの長さを取得 */
let size = deque.len();
/* キューが空かどうかチェック */
let is_empty = deque.is_empty();
```
=== "C"
```c title="queue.c"
// Cは組み込みのキューを提供していません
```
=== "Kotlin"
```kotlin title="queue.kt"
```
=== "Zig"
```zig title="queue.zig"
```
## 5.2.2 &nbsp; キューの実装
キューを実装するには、一方の端で要素を追加し、もう一方の端で要素を削除できるデータ構造が必要です。連結リストと配列の両方がこの要件を満たします。
### 1. &nbsp; 連結リストベースの実装
下図に示すように、連結リストの「ヘッドノード」と「テールノード」をそれぞれキューの「フロント」と「リア」と考えることができます。ノードは後ろでのみ追加でき、前でのみ削除できるように規定されています。
=== "LinkedListQueue"
![連結リストによるキュー実装のエンキューとデキュー操作](queue.assets/linkedlist_queue_step1.png){ class="animation-figure" }
=== "push()"
![linkedlist_queue_push](queue.assets/linkedlist_queue_step2_push.png){ class="animation-figure" }
=== "pop()"
![linkedlist_queue_pop](queue.assets/linkedlist_queue_step3_pop.png){ class="animation-figure" }
<p align="center"> 図 5-5 &nbsp; 連結リストによるキュー実装のエンキューとデキュー操作 </p>
以下は、連結リストを使用してキューを実装するコードです：
=== "Python"
```python title="linkedlist_queue.py"
class LinkedListQueue:
"""連結リストベースのキュークラス"""
def __init__(self):
"""コンストラクタ"""
self._front: ListNode | None = None # ヘッドノード front
self._rear: ListNode | None = None # テールノード rear
self._size: int = 0
def size(self) -> int:
"""キューの長さを取得"""
return self._size
def is_empty(self) -> bool:
"""キューが空かどうかを判定"""
return self._size == 0
def push(self, num: int):
"""エンキュー"""
# テールノードの後ろに num を追加
node = ListNode(num)
# キューが空の場合、ヘッドとテールノードの両方をそのノードに向ける
if self._front is None:
self._front = node
self._rear = node
# キューが空でない場合、そのノードをテールノードの後ろに追加
else:
self._rear.next = node
self._rear = node
self._size += 1
def pop(self) -> int:
"""デキュー"""
num = self.peek()
# ヘッドノードを削除
self._front = self._front.next
self._size -= 1
return num
def peek(self) -> int:
"""フロント要素にアクセス"""
if self.is_empty():
raise IndexError("Queue is empty")
return self._front.val
def to_list(self) -> list[int]:
"""出力用のリストに変換"""
queue = []
temp = self._front
while temp:
queue.append(temp.val)
temp = temp.next
return queue
```
=== "C++"
```cpp title="linkedlist_queue.cpp"
/* 連結リストに基づくキュークラス */
class LinkedListQueue {
private:
ListNode *front, *rear; // 先頭ノードfront、末尾ノードrear
int queSize;
public:
LinkedListQueue() {
front = nullptr;
rear = nullptr;
queSize = 0;
}
~LinkedListQueue() {
// 連結リストを走査、ノードを削除、メモリを解放
freeMemoryLinkedList(front);
}
/* キューの長さを取得 */
int size() {
return queSize;
}
/* キューが空かどうかを判定 */
bool isEmpty() {
return queSize == 0;
}
/* エンキュー */
void push(int num) {
// 末尾ノードの後ろにnumを追加
ListNode *node = new ListNode(num);
// キューが空の場合、先頭と末尾ノードの両方をそのノードに向ける
if (front == nullptr) {
front = node;
rear = node;
}
// キューが空でない場合、そのノードを末尾ノードの後ろに追加
else {
rear->next = node;
rear = node;
}
queSize++;
}
/* デキュー */
int pop() {
int num = peek();
// 先頭ノードを削除
ListNode *tmp = front;
front = front->next;
// メモリを解放
delete tmp;
queSize--;
return num;
}
/* 先頭要素にアクセス */
int peek() {
if (size() == 0)
throw out_of_range("Queue is empty");
return front->val;
}
/* 連結リストをVectorに変換して返却 */
vector<int> toVector() {
ListNode *node = front;
vector<int> res(size());
for (int i = 0; i < res.size(); i++) {
res[i] = node->val;
node = node->next;
}
return res;
}
};
```
=== "Java"
```java title="linkedlist_queue.java"
/* 連結リストに基づくキュークラス */
class LinkedListQueue {
private ListNode front, rear; // 先頭ノード front、末尾ノード rear
private int queSize = 0;
public LinkedListQueue() {
front = null;
rear = null;
}
/* キューの長さを取得 */
public int size() {
return queSize;
}
/* キューが空かどうかを判定 */
public boolean isEmpty() {
return size() == 0;
}
/* エンキュー */
public void push(int num) {
// 末尾ノードの後ろに num を追加
ListNode node = new ListNode(num);
// キューが空の場合、先頭と末尾ノードの両方をそのノードにポイント
if (front == null) {
front = node;
rear = node;
// キューが空でない場合、そのノードを末尾ノードの後ろに追加
} else {
rear.next = node;
rear = node;
}
queSize++;
}
/* デキュー */
public int pop() {
int num = peek();
// 先頭ノードを削除
front = front.next;
queSize--;
return num;
}
/* 先頭要素にアクセス */
public int peek() {
if (isEmpty())
throw new IndexOutOfBoundsException();
return front.val;
}
/* 連結リストを配列に変換して返す */
public int[] toArray() {
ListNode node = front;
int[] res = new int[size()];
for (int i = 0; i < res.length; i++) {
res[i] = node.val;
node = node.next;
}
return res;
}
}
```
=== "C#"
```csharp title="linkedlist_queue.cs"
[class]{LinkedListQueue}-[func]{}
```
=== "Go"
```go title="linkedlist_queue.go"
[class]{linkedListQueue}-[func]{}
```
=== "Swift"
```swift title="linkedlist_queue.swift"
[class]{LinkedListQueue}-[func]{}
```
=== "JS"
```javascript title="linkedlist_queue.js"
[class]{LinkedListQueue}-[func]{}
```
=== "TS"
```typescript title="linkedlist_queue.ts"
[class]{LinkedListQueue}-[func]{}
```
=== "Dart"
```dart title="linkedlist_queue.dart"
[class]{LinkedListQueue}-[func]{}
```
=== "Rust"
```rust title="linkedlist_queue.rs"
[class]{LinkedListQueue}-[func]{}
```
=== "C"
```c title="linkedlist_queue.c"
[class]{LinkedListQueue}-[func]{}
```
=== "Kotlin"
```kotlin title="linkedlist_queue.kt"
[class]{LinkedListQueue}-[func]{}
```
=== "Ruby"
```ruby title="linkedlist_queue.rb"
[class]{LinkedListQueue}-[func]{}
```
=== "Zig"
```zig title="linkedlist_queue.zig"
[class]{LinkedListQueue}-[func]{}
```
### 2. &nbsp; 配列ベースの実装
配列の最初の要素を削除する時間計算量は$O(n)$で、デキュー操作が非効率になります。しかし、この問題は以下のように巧妙に回避できます。
変数`front`を使用してフロント要素のインデックスを示し、変数`size`を維持してキューの長さを記録します。`rear = front + size`を定義し、これはテール要素の直後の位置を指します。
この設計により、**配列内の要素の有効な間隔は`[front, rear - 1]`です**。各操作の実装方法を下図に示します。
- エンキュー操作：入力要素を`rear`インデックスに割り当て、`size`を1増加させます。
- デキュー操作：単に`front`を1増加させ、`size`を1減少させます。
エンキューとデキュー操作は両方とも単一の操作のみを必要とし、それぞれの時間計算量は$O(1)$です。
=== "ArrayQueue"
![配列によるキュー実装のエンキューとデキュー操作](queue.assets/array_queue_step1.png){ class="animation-figure" }
=== "push()"
![array_queue_push](queue.assets/array_queue_step2_push.png){ class="animation-figure" }
=== "pop()"
![array_queue_pop](queue.assets/array_queue_step3_pop.png){ class="animation-figure" }
<p align="center"> 図 5-6 &nbsp; 配列によるキュー実装のエンキューとデキュー操作 </p>
問題に気づくかもしれません：エンキューとデキュー操作が継続的に実行されると、`front`と`rear`の両方が右に移動し、**最終的に配列の末尾に到達してそれ以上移動できなくなります**。これを解決するために、配列を「循環配列」として扱い、配列の末尾を先頭に接続します。
循環配列では、`front`または`rear`が末尾に到達すると、配列の先頭にループバックする必要があります。この循環パターンは、以下のコードに示すように「剰余演算」で実現できます：
=== "Python"
```python title="array_queue.py"
class ArrayQueue:
"""循環配列ベースのキュークラス"""
def __init__(self, size: int):
"""コンストラクタ"""
self._nums: list[int] = [0] * size # キュー要素を格納する配列
self._front: int = 0 # フロントポインタ、フロント要素を指す
self._size: int = 0 # キューの長さ
def capacity(self) -> int:
"""キューの容量を取得"""
return len(self._nums)
def size(self) -> int:
"""キューの長さを取得"""
return self._size
def is_empty(self) -> bool:
"""キューが空かどうかを判定"""
return self._size == 0
def push(self, num: int):
"""エンキュー"""
if self._size == self.capacity():
raise IndexError("Queue is full")
# リアポインタを計算、リアインデックス + 1 を指す
# モジュロ演算を使用してリアポインタを配列の末尾から先頭に戻す
rear: int = (self._front + self._size) % self.capacity()
# num をリアに追加
self._nums[rear] = num
self._size += 1
def pop(self) -> int:
"""デキュー"""
num: int = self.peek()
# フロントポインタを1つ後ろに移動、末尾を超えた場合は配列の先頭に戻る
self._front = (self._front + 1) % self.capacity()
self._size -= 1
return num
def peek(self) -> int:
"""フロント要素にアクセス"""
if self.is_empty():
raise IndexError("Queue is empty")
return self._nums[self._front]
def to_list(self) -> list[int]:
"""出力用の配列を返す"""
res = [0] * self.size()
j: int = self._front
for i in range(self.size()):
res[i] = self._nums[(j % self.capacity())]
j += 1
return res
```
=== "C++"
```cpp title="array_queue.cpp"
/* 循環配列に基づくキュークラス */
class ArrayQueue {
private:
int *nums; // キュー要素を格納する配列
int front; // 先頭ポインタ、先頭要素を指す
int queSize; // キューの長さ
int queCapacity; // キューの容量
public:
ArrayQueue(int capacity) {
// 配列を初期化
nums = new int[capacity];
queCapacity = capacity;
front = queSize = 0;
}
~ArrayQueue() {
delete[] nums;
}
/* キューの容量を取得 */
int capacity() {
return queCapacity;
}
/* キューの長さを取得 */
int size() {
return queSize;
}
/* キューが空かどうかを判定 */
bool isEmpty() {
return size() == 0;
}
/* エンキュー */
void push(int num) {
if (queSize == queCapacity) {
cout << "Queue is full" << endl;
return;
}
// 末尾ポインタを計算、末尾インデックス + 1を指す
// 剰余演算を使用して末尾ポインタが配列の末尾から先頭に戻るようにラップ
int rear = (front + queSize) % queCapacity;
// numを末尾に追加
nums[rear] = num;
queSize++;
}
/* デキュー */
int pop() {
int num = peek();
// 先頭ポインタを1つ後ろに移動、末尾を超えた場合は配列の先頭に戻る
front = (front + 1) % queCapacity;
queSize--;
return num;
}
/* 先頭要素にアクセス */
int peek() {
if (isEmpty())
throw out_of_range("Queue is empty");
return nums[front];
}
/* 配列をVectorに変換して返却 */
vector<int> toVector() {
// 有効な長さ範囲内の要素のみを変換
vector<int> arr(queSize);
for (int i = 0, j = front; i < queSize; i++, j++) {
arr[i] = nums[j % queCapacity];
}
return arr;
}
};
```
=== "Java"
```java title="array_queue.java"
/* 配列に基づくキュークラス */
class ArrayQueue {
private int[] nums; // 要素を格納する配列
private int front; // キューヘッドポインタ、最初の要素を指す
private int queSize; // キューの長さ
public ArrayQueue(int capacity) {
nums = new int[capacity];
front = queSize = 0;
}
/* キューの容量を取得 */
public int capacity() {
return nums.length;
}
/* キューの長さを取得 */
public int size() {
return queSize;
}
/* キューが空かどうかを判定 */
public boolean isEmpty() {
return queSize == 0;
}
/* エンキュー */
public void push(int num) {
if (queSize == capacity()) {
System.out.println("キューが満杯です");
return;
}
// リアポインタを計算：front + queSize
// モジュロ操作により rear が配列の長さを超えることを回避
int rear = (front + queSize) % capacity();
// 要素をキューリアに追加
nums[rear] = num;
queSize++;
}
/* デキュー */
public int pop() {
int num = peek();
// キューヘッドポインタを後ろに1つ移動、モジュロ操作により範囲を超えることを回避
front = (front + 1) % capacity();
queSize--;
return num;
}
/* キューヘッド要素にアクセス */
public int peek() {
if (isEmpty())
throw new IndexOutOfBoundsException();
return nums[front];
}
/* 配列を返す */
public int[] toArray() {
// front から開始して queSize 個の要素のみをコピー
int[] res = new int[queSize];
for (int i = 0, j = front; i < queSize; i++, j++) {
res[i] = nums[j % capacity()];
}
return res;
}
}
```
=== "C#"
```csharp title="array_queue.cs"
[class]{ArrayQueue}-[func]{}
```
=== "Go"
```go title="array_queue.go"
[class]{arrayQueue}-[func]{}
```
=== "Swift"
```swift title="array_queue.swift"
[class]{ArrayQueue}-[func]{}
```
=== "JS"
```javascript title="array_queue.js"
[class]{ArrayQueue}-[func]{}
```
=== "TS"
```typescript title="array_queue.ts"
[class]{ArrayQueue}-[func]{}
```
=== "Dart"
```dart title="array_queue.dart"
[class]{ArrayQueue}-[func]{}
```
=== "Rust"
```rust title="array_queue.rs"
[class]{ArrayQueue}-[func]{}
```
=== "C"
```c title="array_queue.c"
[class]{ArrayQueue}-[func]{}
```
=== "Kotlin"
```kotlin title="array_queue.kt"
[class]{ArrayQueue}-[func]{}
```
=== "Ruby"
```ruby title="array_queue.rb"
[class]{ArrayQueue}-[func]{}
```
=== "Zig"
```zig title="array_queue.zig"
[class]{ArrayQueue}-[func]{}
```
上記のキュー実装にはまだ制限があります：長さが固定されています。しかし、この問題は解決が困難ではありません。配列を必要に応じて自動拡張できる動的配列に置き換えることができます。興味のある読者は自分で実装してみてください。
2つの実装の比較はスタックの場合と一貫しており、ここでは繰り返しません。
## 5.2.3 &nbsp; キューの典型的な応用
- **Amazonの注文**：買い物客が注文を行った後、これらの注文はキューに参加し、システムは順番に処理します。独身の日などのイベント中は、短時間で大量の注文が生成され、高い同時実行性がエンジニアにとって重要な課題となります。
- **様々なToDoリスト**：「先着順」機能が必要なシナリオ、例えばプリンターのタスクキューやレストランの配達キューなど、キューで処理順序を効果的に維持できます。
ja/docs/chapter_stack_and_queue/stack.md
+832
View File
@@ -0,0 +1,832 @@
---
comments: true
---
# 5.1 &nbsp; スタック
<u>スタック</u>は、後入先出（LIFO）の原則に従う線形データ構造です。
スタックをテーブル上の皿の山に例えることができます。底の皿にアクセスするには、まず上の皿を取り除く必要があります。皿を様々な種類の要素（整数、文字、オブジェクトなど）に置き換えることで、スタックと呼ばれるデータ構造を得ることができます。
下図に示すように、要素の山の上部を「スタックのトップ」、下部を「スタックのボトム」と呼びます。スタックのトップに要素を追加する操作を「プッシュ」、トップ要素を削除する操作を「ポップ」と呼びます。
![スタックの後入先出ルール](stack.assets/stack_operations.png){ class="animation-figure" }
<p align="center"> 図 5-1 &nbsp; スタックの後入先出ルール </p>
## 5.1.1 &nbsp; スタックの一般的な操作
スタックの一般的な操作を下表に示します。具体的なメソッド名は使用するプログラミング言語によって異なります。ここでは、例として`push()`、`pop()`、`peek()`を使用します。
<p align="center"> 表 5-1 &nbsp; スタック操作の効率 </p>
<div class="center-table" markdown>
| メソッド | 説明 | 時間計算量 |
| -------- | ----------------------------------------------- | --------------- |
| `push()` | 要素をスタックにプッシュ（トップに追加） | $O(1)$ |
| `pop()` | スタックからトップ要素をポップ | $O(1)$ |
| `peek()` | スタックのトップ要素にアクセス | $O(1)$ |
</div>
通常、プログラミング言語に組み込まれているスタッククラスを直接使用できます。ただし、一部の言語では具体的にスタッククラスを提供していない場合があります。これらの場合、言語の「配列」または「連結リスト」をスタックとして使用し、プログラムでスタックロジックに関連しない操作を無視できます。
=== "Python"
```python title="stack.py"
# スタックを初期化
# Pythonには組み込みのスタッククラスがないため、listをスタックとして使用
stack: list[int] = []
# 要素をスタックにプッシュ
stack.append(1)
stack.append(3)
stack.append(2)
stack.append(5)
stack.append(4)
# スタックのトップ要素にアクセス
peek: int = stack[-1]
# スタックから要素をポップ
pop: int = stack.pop()
# スタックの長さを取得
size: int = len(stack)
# スタックが空かどうかチェック
is_empty: bool = len(stack) == 0
```
=== "C++"
```cpp title="stack.cpp"
/* スタックを初期化 */
stack<int> stack;
/* 要素をスタックにプッシュ */
stack.push(1);
stack.push(3);
stack.push(2);
stack.push(5);
stack.push(4);
/* スタックのトップ要素にアクセス */
int top = stack.top();
/* スタックから要素をポップ */
stack.pop(); // 戻り値なし
/* スタックの長さを取得 */
int size = stack.size();
/* スタックが空かどうかチェック */
bool empty = stack.empty();
```
=== "Java"
```java title="stack.java"
/* スタックを初期化 */
Stack<Integer> stack = new Stack<>();
/* 要素をスタックにプッシュ */
stack.push(1);
stack.push(3);
stack.push(2);
stack.push(5);
stack.push(4);
/* スタックのトップ要素にアクセス */
int peek = stack.peek();
/* スタックから要素をポップ */
int pop = stack.pop();
/* スタックの長さを取得 */
int size = stack.size();
/* スタックが空かどうかチェック */
boolean isEmpty = stack.isEmpty();
```
=== "C#"
```csharp title="stack.cs"
/* スタックを初期化 */
Stack<int> stack = new();
/* 要素をスタックにプッシュ */
stack.Push(1);
stack.Push(3);
stack.Push(2);
stack.Push(5);
stack.Push(4);
/* スタックのトップ要素にアクセス */
int peek = stack.Peek();
/* スタックから要素をポップ */
int pop = stack.Pop();
/* スタックの長さを取得 */
int size = stack.Count;
/* スタックが空かどうかチェック */
bool isEmpty = stack.Count == 0;
```
=== "Go"
```go title="stack_test.go"
/* スタックを初期化 */
// Goでは、Sliceをスタックとして使用することが推奨されます
var stack []int
/* 要素をスタックにプッシュ */
stack = append(stack, 1)
stack = append(stack, 3)
stack = append(stack, 2)
stack = append(stack, 5)
stack = append(stack, 4)
/* スタックのトップ要素にアクセス */
peek := stack[len(stack)-1]
/* スタックから要素をポップ */
pop := stack[len(stack)-1]
stack = stack[:len(stack)-1]
/* スタックの長さを取得 */
size := len(stack)
/* スタックが空かどうかチェック */
isEmpty := len(stack) == 0
```
=== "Swift"
```swift title="stack.swift"
/* スタックを初期化 */
// Swiftには組み込みのスタッククラスがないため、Arrayをスタックとして使用
var stack: [Int] = []
/* 要素をスタックにプッシュ */
stack.append(1)
stack.append(3)
stack.append(2)
stack.append(5)
stack.append(4)
/* スタックのトップ要素にアクセス */
let peek = stack.last!
/* スタックから要素をポップ */
let pop = stack.removeLast()
/* スタックの長さを取得 */
let size = stack.count
/* スタックが空かどうかチェック */
let isEmpty = stack.isEmpty
```
=== "JS"
```javascript title="stack.js"
/* スタックを初期化 */
// JavaScriptには組み込みのスタッククラスがないため、Arrayをスタックとして使用
const stack = [];
/* 要素をスタックにプッシュ */
stack.push(1);
stack.push(3);
stack.push(2);
stack.push(5);
stack.push(4);
/* スタックのトップ要素にアクセス */
const peek = stack[stack.length-1];
/* スタックから要素をポップ */
const pop = stack.pop();
/* スタックの長さを取得 */
const size = stack.length;
/* スタックが空かどうかチェック */
const is_empty = stack.length === 0;
```
=== "TS"
```typescript title="stack.ts"
/* スタックを初期化 */
// TypeScriptには組み込みのスタッククラスがないため、Arrayをスタックとして使用
const stack: number[] = [];
/* 要素をスタックにプッシュ */
stack.push(1);
stack.push(3);
stack.push(2);
stack.push(5);
stack.push(4);
/* スタックのトップ要素にアクセス */
const peek = stack[stack.length - 1];
/* スタックから要素をポップ */
const pop = stack.pop();
/* スタックの長さを取得 */
const size = stack.length;
/* スタックが空かどうかチェック */
const is_empty = stack.length === 0;
```
=== "Dart"
```dart title="stack.dart"
/* スタックを初期化 */
// Dartには組み込みのスタッククラスがないため、Listをスタックとして使用
List<int> stack = [];
/* 要素をスタックにプッシュ */
stack.add(1);
stack.add(3);
stack.add(2);
stack.add(5);
stack.add(4);
/* スタックのトップ要素にアクセス */
int peek = stack.last;
/* スタックから要素をポップ */
int pop = stack.removeLast();
/* スタックの長さを取得 */
int size = stack.length;
/* スタックが空かどうかチェック */
bool isEmpty = stack.isEmpty;
```
=== "Rust"
```rust title="stack.rs"
/* スタックを初期化 */
// Vecをスタックとして使用
let mut stack: Vec<i32> = Vec::new();
/* 要素をスタックにプッシュ */
stack.push(1);
stack.push(3);
stack.push(2);
stack.push(5);
stack.push(4);
/* スタックのトップ要素にアクセス */
let top = stack.last().unwrap();
/* スタックから要素をポップ */
let pop = stack.pop().unwrap();
/* スタックの長さを取得 */
let size = stack.len();
/* スタックが空かどうかチェック */
let is_empty = stack.is_empty();
```
=== "C"
```c title="stack.c"
// Cは組み込みのスタックを提供していません
```
=== "Kotlin"
```kotlin title="stack.kt"
```
=== "Zig"
```zig title="stack.zig"
```
## 5.1.2 &nbsp; スタックの実装
スタックがどのように動作するかをより深く理解するために、自分でスタッククラスを実装してみましょう。
スタックは後入先出の原則に従うため、スタックのトップでのみ要素を追加または削除できます。しかし、配列と連結リストの両方は任意の位置で要素を追加・削除できるため、**スタックは制限された配列または連結リストと見なすことができます**。言い換えれば、配列や連結リストの特定の無関係な操作を「遮蔽」して、外部の動作をスタックの特性に合わせることができます。
### 1. &nbsp; 連結リストベースの実装
連結リストを使用してスタックを実装する場合、リストのヘッドノードをスタックのトップ、テールノードをスタックのボトムと考えることができます。
下図に示すように、プッシュ操作では、単に連結リストのヘッドに要素を挿入します。このノード挿入方法は「ヘッド挿入」として知られています。ポップ操作では、リストからヘッドノードを削除するだけです。
=== "LinkedListStack"
![連結リストによるスタック実装のプッシュとポップ操作](stack.assets/linkedlist_stack_step1.png){ class="animation-figure" }
=== "push()"
![linkedlist_stack_push](stack.assets/linkedlist_stack_step2_push.png){ class="animation-figure" }
=== "pop()"
![linkedlist_stack_pop](stack.assets/linkedlist_stack_step3_pop.png){ class="animation-figure" }
<p align="center"> 図 5-2 &nbsp; 連結リストによるスタック実装のプッシュとポップ操作 </p>
以下は、連結リストに基づくスタック実装のサンプルコードです：
=== "Python"
```python title="linkedlist_stack.py"
class LinkedListStack:
"""連結リストベースのスタッククラス"""
def __init__(self):
"""コンストラクタ"""
self._peek: ListNode | None = None
self._size: int = 0
def size(self) -> int:
"""スタックの長さを取得"""
return self._size
def is_empty(self) -> bool:
"""スタックが空かどうかを判定"""
return self._size == 0
def push(self, val: int):
"""プッシュ"""
node = ListNode(val)
node.next = self._peek
self._peek = node
self._size += 1
def pop(self) -> int:
"""ポップ"""
num = self.peek()
self._peek = self._peek.next
self._size -= 1
return num
def peek(self) -> int:
"""スタックトップ要素にアクセス"""
if self.is_empty():
raise IndexError("Stack is empty")
return self._peek.val
def to_list(self) -> list[int]:
"""出力用のリストに変換"""
arr = []
node = self._peek
while node:
arr.append(node.val)
node = node.next
arr.reverse()
return arr
```
=== "C++"
```cpp title="linkedlist_stack.cpp"
/* 連結リストに基づくスタッククラス */
class LinkedListStack {
private:
ListNode *stackTop; // 先頭ノードをスタックトップとして使用
int stkSize; // スタックの長さ
public:
LinkedListStack() {
stackTop = nullptr;
stkSize = 0;
}
~LinkedListStack() {
// 連結リストを走査、ノードを削除、メモリを解放
freeMemoryLinkedList(stackTop);
}
/* スタックの長さを取得 */
int size() {
return stkSize;
}
/* スタックが空かどうかを判定 */
bool isEmpty() {
return size() == 0;
}
/* プッシュ */
void push(int num) {
ListNode *node = new ListNode(num);
node->next = stackTop;
stackTop = node;
stkSize++;
}
/* ポップ */
int pop() {
int num = top();
ListNode *tmp = stackTop;
stackTop = stackTop->next;
// メモリを解放
delete tmp;
stkSize--;
return num;
}
/* スタックトップ要素にアクセス */
int top() {
if (isEmpty())
throw out_of_range("Stack is empty");
return stackTop->val;
}
/* リストを配列に変換して返却 */
vector<int> toVector() {
ListNode *node = stackTop;
vector<int> res(size());
for (int i = res.size() - 1; i >= 0; i--) {
res[i] = node->val;
node = node->next;
}
return res;
}
};
```
=== "Java"
```java title="linkedlist_stack.java"
/* 連結リストに基づくスタッククラス */
class LinkedListStack {
private ListNode stackPeek; // ヘッドノードをスタックトップとして使用
private int stkSize = 0; // スタックの長さ
public LinkedListStack() {
stackPeek = null;
}
/* スタックの長さを取得 */
public int size() {
return stkSize;
}
/* スタックが空かどうかを判定 */
public boolean isEmpty() {
return size() == 0;
}
/* プッシュ */
public void push(int num) {
ListNode node = new ListNode(num);
node.next = stackPeek;
stackPeek = node;
stkSize++;
}
/* ポップ */
public int pop() {
int num = peek();
stackPeek = stackPeek.next;
stkSize--;
return num;
}
/* スタックトップ要素にアクセス */
public int peek() {
if (isEmpty())
throw new IndexOutOfBoundsException();
return stackPeek.val;
}
/* List を Array に変換して返す */
public int[] toArray() {
ListNode node = stackPeek;
int[] res = new int[size()];
for (int i = res.length - 1; i >= 0; i--) {
res[i] = node.val;
node = node.next;
}
return res;
}
}
```
=== "C#"
```csharp title="linkedlist_stack.cs"
[class]{LinkedListStack}-[func]{}
```
=== "Go"
```go title="linkedlist_stack.go"
[class]{linkedListStack}-[func]{}
```
=== "Swift"
```swift title="linkedlist_stack.swift"
[class]{LinkedListStack}-[func]{}
```
=== "JS"
```javascript title="linkedlist_stack.js"
[class]{LinkedListStack}-[func]{}
```
=== "TS"
```typescript title="linkedlist_stack.ts"
[class]{LinkedListStack}-[func]{}
```
=== "Dart"
```dart title="linkedlist_stack.dart"
[class]{LinkedListStack}-[func]{}
```
=== "Rust"
```rust title="linkedlist_stack.rs"
[class]{LinkedListStack}-[func]{}
```
=== "C"
```c title="linkedlist_stack.c"
[class]{LinkedListStack}-[func]{}
```
=== "Kotlin"
```kotlin title="linkedlist_stack.kt"
[class]{LinkedListStack}-[func]{}
```
=== "Ruby"
```ruby title="linkedlist_stack.rb"
[class]{LinkedListStack}-[func]{}
```
=== "Zig"
```zig title="linkedlist_stack.zig"
[class]{LinkedListStack}-[func]{}
```
### 2. &nbsp; 配列ベースの実装
配列を使用してスタックを実装する場合、配列の末尾をスタックのトップと考えることができます。下図に示すように、プッシュとポップ操作は、それぞれ配列の末尾での要素の追加と削除に対応し、どちらも時間計算量$O(1)$です。
=== "ArrayStack"
![配列によるスタック実装のプッシュとポップ操作](stack.assets/array_stack_step1.png){ class="animation-figure" }
=== "push()"
![array_stack_push](stack.assets/array_stack_step2_push.png){ class="animation-figure" }
=== "pop()"
![array_stack_pop](stack.assets/array_stack_step3_pop.png){ class="animation-figure" }
<p align="center"> 図 5-3 &nbsp; 配列によるスタック実装のプッシュとポップ操作 </p>
スタックにプッシュされる要素が継続的に増加する可能性があるため、動的配列を使用でき、配列拡張を自分で処理する必要がありません。以下はサンプルコードです：
=== "Python"
```python title="array_stack.py"
class ArrayStack:
"""配列ベースのスタッククラス"""
def __init__(self):
"""コンストラクタ"""
self._stack: list[int] = []
def size(self) -> int:
"""スタックの長さを取得"""
return len(self._stack)
def is_empty(self) -> bool:
"""スタックが空かどうかを判定"""
return self.size() == 0
def push(self, item: int):
"""プッシュ"""
self._stack.append(item)
def pop(self) -> int:
"""ポップ"""
if self.is_empty():
raise IndexError("Stack is empty")
return self._stack.pop()
def peek(self) -> int:
"""スタックトップ要素にアクセス"""
if self.is_empty():
raise IndexError("Stack is empty")
return self._stack[-1]
def to_list(self) -> list[int]:
"""出力用の配列を返す"""
return self._stack
```
=== "C++"
```cpp title="array_stack.cpp"
/* 配列に基づくスタッククラス */
class ArrayStack {
private:
vector<int> stack;
public:
/* スタックの長さを取得 */
int size() {
return stack.size();
}
/* スタックが空かどうかを判定 */
bool isEmpty() {
return stack.size() == 0;
}
/* プッシュ */
void push(int num) {
stack.push_back(num);
}
/* ポップ */
int pop() {
int num = top();
stack.pop_back();
return num;
}
/* スタックトップ要素にアクセス */
int top() {
if (isEmpty())
throw out_of_range("Stack is empty");
return stack.back();
}
/* Vectorを返却 */
vector<int> toVector() {
return stack;
}
};
```
=== "Java"
```java title="array_stack.java"
/* 配列に基づくスタッククラス */
class ArrayStack {
private ArrayList<Integer> stack;
public ArrayStack() {
// リスト（動的配列）を初期化
stack = new ArrayList<>();
}
/* スタックの長さを取得 */
public int size() {
return stack.size();
}
/* スタックが空かどうかを判定 */
public boolean isEmpty() {
return size() == 0;
}
/* プッシュ */
public void push(int num) {
stack.add(num);
}
/* ポップ */
public int pop() {
if (isEmpty())
throw new IndexOutOfBoundsException();
return stack.remove(size() - 1);
}
/* スタックトップ要素にアクセス */
public int peek() {
if (isEmpty())
throw new IndexOutOfBoundsException();
return stack.get(size() - 1);
}
/* List を Array に変換して返す */
public Object[] toArray() {
return stack.toArray();
}
}
```
=== "C#"
```csharp title="array_stack.cs"
[class]{ArrayStack}-[func]{}
```
=== "Go"
```go title="array_stack.go"
[class]{arrayStack}-[func]{}
```
=== "Swift"
```swift title="array_stack.swift"
[class]{ArrayStack}-[func]{}
```
=== "JS"
```javascript title="array_stack.js"
[class]{ArrayStack}-[func]{}
```
=== "TS"
```typescript title="array_stack.ts"
[class]{ArrayStack}-[func]{}
```
=== "Dart"
```dart title="array_stack.dart"
[class]{ArrayStack}-[func]{}
```
=== "Rust"
```rust title="array_stack.rs"
[class]{ArrayStack}-[func]{}
```
=== "C"
```c title="array_stack.c"
[class]{ArrayStack}-[func]{}
```
=== "Kotlin"
```kotlin title="array_stack.kt"
[class]{ArrayStack}-[func]{}
```
=== "Ruby"
```ruby title="array_stack.rb"
[class]{ArrayStack}-[func]{}
```
=== "Zig"
```zig title="array_stack.zig"
[class]{ArrayStack}-[func]{}
```
## 5.1.3 &nbsp; 2つの実装の比較
**サポートされる操作**
両方の実装は、スタックで定義されたすべての操作をサポートします。配列実装はさらにランダムアクセスをサポートしますが、これはスタック定義の範囲を超えており、一般的には使用されません。
**時間効率**
配列ベースの実装では、プッシュとポップ操作の両方が事前に割り当てられた連続メモリで発生し、良好なキャッシュ局所性があるため効率が高くなります。しかし、プッシュ操作が配列容量を超える場合、リサイズメカニズムがトリガーされ、そのプッシュ操作の時間計算量は$O(n)$になります。
連結リスト実装では、リスト拡張は非常に柔軟で、配列拡張のような効率低下の問題はありません。しかし、プッシュ操作にはノードオブジェクトの初期化とポインタの変更が必要なため、効率は比較的低くなります。プッシュされる要素がすでにノードオブジェクトの場合、初期化ステップをスキップでき、効率が向上します。
したがって、プッシュとポップ操作の要素が`int`や`double`などの基本データ型の場合、以下の結論を導くことができます：
- 配列ベースのスタック実装は拡張時に効率が低下しますが、拡張は低頻度操作であるため、平均効率は高くなります。
- 連結リストベースのスタック実装はより安定した効率パフォーマンスを提供します。
**空間効率**
リストを初期化する際、システムは「初期容量」を割り当てますが、これは実際の必要量を超える可能性があります。さらに、拡張メカニズムは通常、特定の係数（2倍など）で容量を増加させ、これも実際の必要量を超える可能性があります。したがって、**配列ベースのスタックは一部の空間を無駄にする可能性があります**。
しかし、連結リストノードはポインタを格納するための追加空間が必要なため、**連結リストノードが占有する空間は比較的大きくなります**。
まとめると、どちらの実装がよりメモリ効率的かを単純に判断することはできません。特定の状況に基づく分析が必要です。
## 5.1.4 &nbsp; スタックの典型的な応用
- **ブラウザの戻ると進む、ソフトウェアの元に戻すとやり直し**。新しいWebページを開くたびに、ブラウザは前のページをスタックにプッシュし、戻る操作（本質的にはポップ操作）を通じて前のページに戻ることができます。戻ると進むの両方をサポートするには、2つのスタックが連携して動作する必要があります。
- **プログラムのメモリ管理**。関数が呼び出されるたびに、システムはスタックのトップにスタックフレームを追加して関数のコンテキスト情報を記録します。再帰関数では、下方向の再帰フェーズはスタックへのプッシュを続け、上方向のバックトラッキングフェーズはスタックからのポップを続けます。
ja/docs/chapter_stack_and_queue/summary.md
+35
View File
@@ -0,0 +1,35 @@
---
comments: true
---
# 5.4 &nbsp; まとめ
### 1. &nbsp; 重要なポイント
- スタックは後入れ先出し（LIFO）の原則に従うデータ構造で、配列または連結リストを使って実装できます。
- 時間効率の観点では、スタックの配列実装の方が平均的な効率が高いです。ただし、拡張時には単一のプッシュ操作の時間計算量が$O(n)$に悪化する可能性があります。対照的に、スタックの連結リスト実装はより安定した効率を提供します。
- 空間効率に関しては、スタックの配列実装は一定程度の空間の無駄につながる可能性があります。ただし、連結リストのノードが占有するメモリ空間は一般的に配列の要素よりも大きいことに注意することが重要です。
- キューは先入れ先出し（FIFO）の原則に従うデータ構造で、同様に配列または連結リストを使って実装できます。キューの時間と空間効率に関する結論は、スタックと似ています。
- 両端キュー（deque）はより柔軟なキューの種類で、両端での要素の追加と削除を可能にします。
### 2. &nbsp; Q & A
**Q**: ブラウザの進む・戻る機能は双方向連結リストで実装されているのですか？
ブラウザの進む・戻るナビゲーションは本質的に「スタック」概念の現れです。ユーザーが新しいページを訪問すると、そのページがスタックの先頭に追加されます。戻るボタンをクリックすると、ページがスタックの先頭からポップされます。両端キュー（deque）は、「両端キュー」の章で述べたように、いくつかの追加操作を便利に実装できます。
**Q**: スタックからポップした後、ポップされたノードのメモリを解放する必要がありますか？
ポップされたノードが後で使用される場合は、そのメモリを解放する必要はありません。自動ガベージコレクションを持つJavaやPythonなどの言語では、手動のメモリ解放は必要ありません。CやC++では、手動のメモリ解放が必要です。
**Q**: 両端キューは2つのスタックを結合したもののように見えます。その用途は何ですか？
両端キューは、スタックとキューの組み合わせまたは2つのスタックを結合したもので、スタックとキューの両方のロジックを示します。したがって、スタックとキューのすべてのアプリケーションを実装でき、より大きな柔軟性を提供します。
**Q**: 元に戻すとやり直しは具体的にどのように実装されるのですか？
元に戻すとやり直しの操作は2つのスタックを使って実装されます：元に戻す用のスタック`A`とやり直し用のスタック`B`です。
1. ユーザーが操作を実行するたびに、それがスタック`A`にプッシュされ、スタック`B`がクリアされます。
2. ユーザーが「元に戻す」を実行すると、最新の操作がスタック`A`からポップされ、スタック`B`にプッシュされます。
3. ユーザーが「やり直し」を実行すると、最新の操作がスタック`B`からポップされ、スタック`A`に戻されます。