build

2026-07-25 04:26:07 +00:00 · 2025-10-17 05:33:23 +08:00
parent 9278f3c659
commit 68bb9afb16
113 changed files with 35936 additions and 0 deletions
@@ -0,0 +1,182 @@
+---
+comments: true
+---
+
+# 8.2 &nbsp; ヒープ構築操作
+
+場合によっては、リストのすべての要素を使用してヒープを構築したいことがあり、このプロセスは「ヒープ構築操作」として知られています。
+
+## 8.2.1 &nbsp; ヒープ挿入操作による実装
+
+まず、空のヒープを作成し、次にリストを反復処理して、各要素に対して順番に「ヒープ挿入操作」を実行します。これは、要素をヒープの末尾に追加し、次に下から上に「ヒープ化」することを意味します。
+
+ヒープに要素が追加されるたびに、ヒープの長さは1つずつ増加します。ノードは二分木に上から下に追加されるため、ヒープは「上から下に」構築されます。
+
+要素数を$n$とすると、各要素の挿入操作は$O(\log{n})$時間かかるため、このヒープ構築方法の時間計算量は$O(n \log n)$です。
+
+## 8.2.2 &nbsp; 走査によるヒープ化の実装
+
+実際には、2つのステップでより効率的なヒープ構築方法を実装できます。
+
+1. リストのすべての要素をそのままヒープに追加します。この時点では、ヒープの性質はまだ満たされていません。
+2. ヒープを逆順（レベル順走査の逆）で走査し、各非葉ノードに対して「上から下のヒープ化」を実行します。
+
+**ノードをヒープ化した後、そのノードを根とする部分木は有効な部分ヒープになります**。走査が逆順であるため、ヒープは「下から上に」構築されます。
+
+逆走査を選択する理由は、現在のノードの下の部分木がすでに有効な部分ヒープであることを保証し、現在のノードのヒープ化を効果的にするためです。
+
+言及する価値があるのは、**葉ノードは子を持たないため、自然に有効な部分ヒープを形成し、ヒープ化する必要がない**ということです。以下のコードに示すように、最後の非葉ノードは最後のノードの親です。そこから開始して逆順に走査してヒープ化を実行します：
+
+=== "Python"
+
+    ```python title="my_heap.py"
+    def __init__(self, nums: list[int]):
+        """コンストラクタ、入力リストに基づいてヒープを構築"""
+        # すべてのリスト要素をヒープに追加
+        self.max_heap = nums
+        # 葉以外のすべてのノードをヒープ化
+        for i in range(self.parent(self.size() - 1), -1, -1):
+            self.sift_down(i)
+    ```
+
+=== "C++"
+
+    ```cpp title="my_heap.cpp"
+    /* コンストラクタ、入力リストに基づいてヒープを構築 */
+    MaxHeap(vector<int> nums) {
+        // すべてのリスト要素をヒープに追加
+        maxHeap = nums;
+        // 葉以外のすべてのノードをヒープ化
+        for (int i = parent(size() - 1); i >= 0; i--) {
+            siftDown(i);
+        }
+    }
+    ```
+
+=== "Java"
+
+    ```java title="my_heap.java"
+    /* コンストラクタ、入力リストに基づいてヒープを構築 */
+    MaxHeap(List<Integer> nums) {
+        // すべてのリスト要素をヒープに追加
+        maxHeap = new ArrayList<>(nums);
+        // 葉を除くすべてのノードをヒープ化
+        for (int i = parent(size() - 1); i >= 0; i--) {
+            siftDown(i);
+        }
+    }
+    ```
+
+=== "C#"
+
+    ```csharp title="my_heap.cs"
+    [class]{MaxHeap}-[func]{MaxHeap}
+    ```
+
+=== "Go"
+
+    ```go title="my_heap.go"
+    [class]{maxHeap}-[func]{newMaxHeap}
+    ```
+
+=== "Swift"
+
+    ```swift title="my_heap.swift"
+    [class]{MaxHeap}-[func]{init}
+    ```
+
+=== "JS"
+
+    ```javascript title="my_heap.js"
+    [class]{MaxHeap}-[func]{constructor}
+    ```
+
+=== "TS"
+
+    ```typescript title="my_heap.ts"
+    [class]{MaxHeap}-[func]{constructor}
+    ```
+
+=== "Dart"
+
+    ```dart title="my_heap.dart"
+    [class]{MaxHeap}-[func]{MaxHeap}
+    ```
+
+=== "Rust"
+
+    ```rust title="my_heap.rs"
+    [class]{MaxHeap}-[func]{new}
+    ```
+
+=== "C"
+
+    ```c title="my_heap.c"
+    [class]{MaxHeap}-[func]{newMaxHeap}
+    ```
+
+=== "Kotlin"
+
+    ```kotlin title="my_heap.kt"
+    [class]{MaxHeap}-[func]{}
+    ```
+
+=== "Ruby"
+
+    ```ruby title="my_heap.rb"
+    [class]{MaxHeap}-[func]{initialize}
+    ```
+
+=== "Zig"
+
+    ```zig title="my_heap.zig"
+    [class]{MaxHeap}-[func]{init}
+    ```
+
+## 8.2.3 &nbsp; 計算量分析
+
+次に、この第2のヒープ構築方法の時間計算量を計算してみましょう。
+
+- 完備二分木のノード数を$n$と仮定すると、葉ノードの数は$(n + 1) / 2$です。ここで$/$ は整数除算です。したがって、ヒープ化が必要なノードの数は$(n - 1) / 2$です。
+- 「上から下のヒープ化」のプロセスでは、各ノードは最大で葉ノードまでヒープ化されるため、最大反復回数は二分木の高さ$\log n$です。
+
+この2つを掛け合わせると、ヒープ構築プロセスの時間計算量は$O(n \log n)$となります。**しかし、この推定は正確ではありません。二分木の下位レベルには上位よりもはるかに多くのノードがあるという性質を考慮していないからです。**
+
+より正確な計算を行いましょう。計算を簡素化するため、$n$個のノードと高さ$h$を持つ「完全二分木」を仮定します。この仮定は結果の正確性に影響しません。
+
+![完全二分木の各レベルのノード数](build_heap.assets/heapify_operations_count.png){ class="animation-figure" }
+
+<p align="center"> 図 8-5 &nbsp; 完全二分木の各レベルのノード数 </p>
+
+上図に示すように、ノードが「上から下にヒープ化される」最大反復回数は、そのノードから葉ノードまでの距離と等しく、これは正確に「ノードの高さ」です。したがって、各レベルで「ノード数×ノードの高さ」を合計して、**すべてのノードの総ヒープ化反復回数を得る**ことができます。
+
+$$
+T(h) = 2^0h + 2^1(h-1) + 2^2(h-2) + \dots + 2^{(h-1)}\times1
+$$
+
+上記の方程式を簡素化するために、高校の数列の知識を使用する必要があります。まず$T(h)$に$2$を掛けて以下を得ます：
+
+$$
+\begin{aligned}
+T(h) & = 2^0h + 2^1(h-1) + 2^2(h-2) + \dots + 2^{h-1}\times1 \newline
+2T(h) & = 2^1h + 2^2(h-1) + 2^3(h-2) + \dots + 2^h\times1 \newline
+\end{aligned}
+$$
+
+変位法を使用して$2T(h)$から$T(h)$を減算すると、以下を得ます：
+
+$$
+2T(h) - T(h) = T(h) = -2^0h + 2^1 + 2^2 + \dots + 2^{h-1} + 2^h
+$$
+
+方程式を観察すると、$T(h)$は等比数列であり、和の公式を使用して直接計算でき、時間計算量は以下になります：
+
+$$
+\begin{aligned}
+T(h) & = 2 \frac{1 - 2^h}{1 - 2} - h \newline
+& = 2^{h+1} - h - 2 \newline
+& = O(2^h)
+\end{aligned}
+$$
+
+さらに、高さ$h$の完全二分木は$n = 2^{h+1} - 1$個のノードを持つため、計算量は$O(2^h) = O(n)$です。この計算は、**リストを入力してヒープを構築する時間計算量が$O(n)$であり、非常に効率的である**ことを示しています。
@@ -0,0 +1,21 @@
+---
+comments: true
+icon: material/family-tree
+---
+
+# 第 8 章 &nbsp; ヒープ
+
+![ヒープ](../assets/covers/chapter_heap.jpg){ class="cover-image" }
+
+!!! abstract
+
+    ヒープは山とその険しい峰のように、層をなして起伏し、それぞれが独特の形を持っています。
+
+    各山の頂は散らばった高さで上下しますが、最も高いものが常に最初に注目を集めます。
+
+## 章の内容
+
+- [8.1 &nbsp; ヒープ](heap.md)
+- [8.2 &nbsp; ヒープの構築](build_heap.md)
+- [8.3 &nbsp; Top-k問題](top_k.md)
+- [8.4 &nbsp; まとめ](summary.md)
@@ -0,0 +1,21 @@
+---
+comments: true
+---
+
+# 8.4 &nbsp; まとめ
+
+### 1. &nbsp; 重要な復習
+
+- ヒープは完備二分木で、その構築性質に基づいて最大ヒープまたは最小ヒープに分類できます。最大ヒープの先頭要素は最大で、最小ヒープの先頭要素は最小です。
+- 優先度キューは、デキューの優先度を持つキューとして定義され、通常ヒープを使用して実装されます。
+- ヒープの一般的な操作とそれに対応する時間計算量には以下があります：ヒープへの要素挿入$O(\log n)$、ヒープからの先頭要素削除$O(\log n)$、ヒープの先頭要素へのアクセス$O(1)$。
+- 完備二分木は配列で表現するのに適しているため、ヒープは一般的に配列を使用して格納されます。
+- ヒープ化操作はヒープの性質を維持するために使用され、ヒープの挿入操作と削除操作の両方で使用されます。
+- $n$個の要素が入力として与えられた場合のヒープ構築の時間計算量は$O(n)$に最適化でき、これは非常に効率的です。
+- Top-kは古典的なアルゴリズム問題で、ヒープデータ構造を使用して効率的に解決でき、時間計算量は$O(n \log k)$です。
+
+### 2. &nbsp; Q & A
+
+**Q**: データ構造の「ヒープ」とメモリ管理の「ヒープ」は同じ概念ですか？
+
+この2つは、どちらも「ヒープ」と呼ばれますが、同じ概念ではありません。コンピュータシステムメモリのヒープは動的メモリ割り当ての一部で、プログラムが実行中にデータを格納するために使用できます。プログラムは、オブジェクトや配列などの複雑な構造を格納するために、一定量のヒープメモリを要求できます。割り当てられたデータが不要になったときは、メモリリークを防ぐためにプログラムがこのメモリを解放する必要があります。スタックメモリと比較して、ヒープメモリの管理と使用にはより多くの注意が必要で、不適切な使用はメモリリークやダングリングポインタにつながる可能性があります。
@@ -0,0 +1,234 @@
+---
+comments: true
+---
+
+# 8.3 &nbsp; Top-k問題
+
+!!! question
+
+    長さ$n$の順序付けられていない配列`nums`が与えられたとき、配列内の最大$k$個の要素を返してください。
+
+この問題について、まず2つの直接的な解法を紹介し、次により効率的なヒープベースの方法を説明します。
+
+## 8.3.1 &nbsp; 方法1：反復選択
+
+下図に示すように、$k$回の反復を実行し、各回で$1$番目、$2$番目、$\dots$、$k$番目に大きい要素を抽出できます。時間計算量は$O(nk)$です。
+
+この方法は$k \ll n$の場合にのみ適しています。$k$が$n$に近い場合、時間計算量は$O(n^2)$に近づき、非常に時間がかかります。
+
+![最大k個の要素を反復的に見つける](top_k.assets/top_k_traversal.png){ class="animation-figure" }
+
+<p align="center"> 図 8-6 &nbsp; 最大k個の要素を反復的に見つける </p>
+
+!!! tip
+
+    $k = n$の場合、完全に順序付けられたシーケンスを得ることができ、これは「選択ソート」アルゴリズムと同等です。
+
+## 8.3.2 &nbsp; 方法2：ソート
+
+下図に示すように、まず配列`nums`をソートし、次に最後の$k$個の要素を返すことができます。時間計算量は$O(n \log n)$です。
+
+明らかに、この方法はタスクを「やりすぎ」ています。最大$k$個の要素を見つけるだけでよく、他の要素をソートする必要はありません。
+
+![ソートによる最大k個の要素の発見](top_k.assets/top_k_sorting.png){ class="animation-figure" }
+
+<p align="center"> 図 8-7 &nbsp; ソートによる最大k個の要素の発見 </p>
+
+## 8.3.3 &nbsp; 方法3：ヒープ
+
+以下のプロセスに示すように、ヒープに基づいてTop-k問題をより効率的に解決できます。
+
+1. 最小ヒープを初期化します。先頭要素が最小になります。
+2. まず、配列の最初の$k$個の要素をヒープに挿入します。
+3. $k + 1$番目の要素から開始し、現在の要素がヒープの先頭要素より大きい場合、ヒープの先頭要素を削除し、現在の要素をヒープに挿入します。
+4. 走査を完了した後、ヒープには最大$k$個の要素が含まれています。
+
+=== "<1>"
+    ![ヒープに基づく最大k個の要素の発見](top_k.assets/top_k_heap_step1.png){ class="animation-figure" }
+
+=== "<2>"
+    ![top_k_heap_step2](top_k.assets/top_k_heap_step2.png){ class="animation-figure" }
+
+=== "<3>"
+    ![top_k_heap_step3](top_k.assets/top_k_heap_step3.png){ class="animation-figure" }
+
+=== "<4>"
+    ![top_k_heap_step4](top_k.assets/top_k_heap_step4.png){ class="animation-figure" }
+
+=== "<5>"
+    ![top_k_heap_step5](top_k.assets/top_k_heap_step5.png){ class="animation-figure" }
+
+=== "<6>"
+    ![top_k_heap_step6](top_k.assets/top_k_heap_step6.png){ class="animation-figure" }
+
+=== "<7>"
+    ![top_k_heap_step7](top_k.assets/top_k_heap_step7.png){ class="animation-figure" }
+
+=== "<8>"
+    ![top_k_heap_step8](top_k.assets/top_k_heap_step8.png){ class="animation-figure" }
+
+=== "<9>"
+    ![top_k_heap_step9](top_k.assets/top_k_heap_step9.png){ class="animation-figure" }
+
+<p align="center"> 図 8-8 &nbsp; ヒープに基づく最大k個の要素の発見 </p>
+
+サンプルコードは以下の通りです：
+
+=== "Python"
+
+    ```python title="top_k.py"
+    def top_k_heap(nums: list[int], k: int) -> list[int]:
+        """ヒープを使用して配列内の最大k個の要素を見つける"""
+        # 最小ヒープを初期化
+        heap = []
+        # 配列の最初のk個の要素をヒープに入力
+        for i in range(k):
+            heapq.heappush(heap, nums[i])
+        # k+1番目の要素から、ヒープの長さをkに保つ
+        for i in range(k, len(nums)):
+            # 現在の要素がヒープの先頭要素より大きい場合、ヒープの先頭要素を削除し、現在の要素をヒープに入力
+            if nums[i] > heap[0]:
+                heapq.heappop(heap)
+                heapq.heappush(heap, nums[i])
+        return heap
+    ```
+
+=== "C++"
+
+    ```cpp title="top_k.cpp"
+    /* ヒープを使用して配列内の最大k個の要素を見つける */
+    priority_queue<int, vector<int>, greater<int>> topKHeap(vector<int> &nums, int k) {
+        // 最小ヒープを初期化
+        priority_queue<int, vector<int>, greater<int>> heap;
+        // 配列の最初のk個の要素をヒープに入力
+        for (int i = 0; i < k; i++) {
+            heap.push(nums[i]);
+        }
+        // k+1番目の要素から、ヒープの長さをkに保つ
+        for (int i = k; i < nums.size(); i++) {
+            // 現在の要素がヒープの先頭要素より大きい場合、ヒープの先頭要素を削除し、現在の要素をヒープに入力
+            if (nums[i] > heap.top()) {
+                heap.pop();
+                heap.push(nums[i]);
+            }
+        }
+        return heap;
+    }
+    ```
+
+=== "Java"
+
+    ```java title="top_k.java"
+    /* ヒープを使用して配列内の最大 k 個の要素を検索 */
+    Queue<Integer> topKHeap(int[] nums, int k) {
+        // 最小ヒープを初期化
+        Queue<Integer> heap = new PriorityQueue<Integer>();
+        // 配列の最初の k 個の要素をヒープに入力
+        for (int i = 0; i < k; i++) {
+            heap.offer(nums[i]);
+        }
+        // k+1 番目の要素から、ヒープの長さを k に保つ
+        for (int i = k; i < nums.length; i++) {
+            // 現在の要素がヒープの先頭要素より大きい場合、ヒープの先頭要素を削除し、現在の要素をヒープに入力
+            if (nums[i] > heap.peek()) {
+                heap.poll();
+                heap.offer(nums[i]);
+            }
+        }
+        return heap;
+    }
+    ```
+
+=== "C#"
+
+    ```csharp title="top_k.cs"
+    [class]{top_k}-[func]{TopKHeap}
+    ```
+
+=== "Go"
+
+    ```go title="top_k.go"
+    [class]{}-[func]{topKHeap}
+    ```
+
+=== "Swift"
+
+    ```swift title="top_k.swift"
+    [class]{}-[func]{topKHeap}
+    ```
+
+=== "JS"
+
+    ```javascript title="top_k.js"
+    [class]{}-[func]{pushMinHeap}
+
+    [class]{}-[func]{popMinHeap}
+
+    [class]{}-[func]{peekMinHeap}
+
+    [class]{}-[func]{getMinHeap}
+
+    [class]{}-[func]{topKHeap}
+    ```
+
+=== "TS"
+
+    ```typescript title="top_k.ts"
+    [class]{}-[func]{pushMinHeap}
+
+    [class]{}-[func]{popMinHeap}
+
+    [class]{}-[func]{peekMinHeap}
+
+    [class]{}-[func]{getMinHeap}
+
+    [class]{}-[func]{topKHeap}
+    ```
+
+=== "Dart"
+
+    ```dart title="top_k.dart"
+    [class]{}-[func]{topKHeap}
+    ```
+
+=== "Rust"
+
+    ```rust title="top_k.rs"
+    [class]{}-[func]{top_k_heap}
+    ```
+
+=== "C"
+
+    ```c title="top_k.c"
+    [class]{}-[func]{pushMinHeap}
+
+    [class]{}-[func]{popMinHeap}
+
+    [class]{}-[func]{peekMinHeap}
+
+    [class]{}-[func]{getMinHeap}
+
+    [class]{}-[func]{topKHeap}
+    ```
+
+=== "Kotlin"
+
+    ```kotlin title="top_k.kt"
+    [class]{}-[func]{topKHeap}
+    ```
+
+=== "Ruby"
+
+    ```ruby title="top_k.rb"
+    [class]{}-[func]{top_k_heap}
+    ```
+
+=== "Zig"
+
+    ```zig title="top_k.zig"
+    [class]{}-[func]{topKHeap}
+    ```
+
+合計$n$回のヒープ挿入と削除が実行され、最大ヒープサイズが$k$であるため、時間計算量は$O(n \log k)$です。この方法は非常に効率的で、$k$が小さい場合、時間計算量は$O(n)$に近づき、$k$が大きい場合でも、時間計算量は$O(n \log n)$を超えません。
+
+さらに、この方法は動的データストリームのシナリオに適しています。データを継続的に追加することで、ヒープ内の要素を維持し、最大$k$個の要素の動的更新を実現できます。