Re-translate the Japanese version (#1871)

* Retranslate Japanese docs with GPT-5.4

* Retranslate Japanese code with GPT-5.4

ja/codes/go/chapter_heap/heap.go

@@ -0,0 +1,45 @@
+// File: heap.go
+// Created Time: 2023-01-12
+// Author: Reanon (793584285@qq.com)
+
+package chapter_heap
+
+// Go では heap.Interface を実装することで整数の最大ヒープを構築できる
+// heap.Interface を実装するには、同時に sort.Interface も実装する必要がある
+type intHeap []any
+
+// Push は heap.Interface の関数で、要素をヒープに追加する
+func (h *intHeap) Push(x any) {
+	// Push と Pop は pointer receiver を使う
+	// これらはスライスの内容を調整するだけでなく、スライスの長さも変更するためである。
+	*h = append(*h, x.(int))
+}
+
+// Pop は heap.Interface の関数で、ヒープの先頭要素を取り出す
+func (h *intHeap) Pop() any {
+	// ヒープから取り出す要素を末尾に置く
+	last := (*h)[len(*h)-1]
+	*h = (*h)[:len(*h)-1]
+	return last
+}
+
+// Len は sort.Interface の関数
+func (h *intHeap) Len() int {
+	return len(*h)
+}
+
+// Less は sort.Interface の関数
+func (h *intHeap) Less(i, j int) bool {
+	// 最小ヒープを実装する場合は、不等号を < に調整する
+	return (*h)[i].(int) > (*h)[j].(int)
+}
+
+// Swap は sort.Interface の関数
+func (h *intHeap) Swap(i, j int) {
+	(*h)[i], (*h)[j] = (*h)[j], (*h)[i]
+}
+
+// Top ヒープ先頭要素を取得
+func (h *intHeap) Top() any {
+	return (*h)[0]
+}

ja/codes/go/chapter_heap/heap_test.go

@@ -0,0 +1,101 @@
+// File: heap_test.go
+// Created Time: 2023-01-12
+// Author: Reanon (793584285@qq.com)
+
+package chapter_heap
+
+import (
+	"container/heap"
+	"fmt"
+	"strconv"
+	"testing"
+
+	. "github.com/krahets/hello-algo/pkg"
+)
+
+func testPush(h *intHeap, val int) {
+	// heap.Interface の関数を呼び出して要素を追加する
+	heap.Push(h, val)
+	fmt.Printf("\n要素 %d をヒープに追加後 \n", val)
+	PrintHeap(*h)
+}
+
+func testPop(h *intHeap) {
+	// heap.Interface の関数を呼び出して要素を削除する
+	val := heap.Pop(h)
+	fmt.Printf("\nヒープ先頭要素 %d を取り出した後 \n", val)
+	PrintHeap(*h)
+}
+
+func TestHeap(t *testing.T) {
+	/* ヒープを初期化 */
+	// 最大ヒープを初期化
+	maxHeap := &intHeap{}
+	heap.Init(maxHeap)
+	/* 要素をヒープに追加 */
+	testPush(maxHeap, 1)
+	testPush(maxHeap, 3)
+	testPush(maxHeap, 2)
+	testPush(maxHeap, 5)
+	testPush(maxHeap, 4)
+
+	/* ヒープ頂点の要素を取得 */
+	top := maxHeap.Top()
+	fmt.Printf("ヒープ先頭要素は %d\n", top)
+
+	/* ヒープ頂点の要素を取り出す */
+	testPop(maxHeap)
+	testPop(maxHeap)
+	testPop(maxHeap)
+	testPop(maxHeap)
+	testPop(maxHeap)
+
+	/* ヒープのサイズを取得 */
+	size := len(*maxHeap)
+	fmt.Printf("ヒープの要素数は %d\n", size)
+
+	/* ヒープが空かどうかを判定 */
+	isEmpty := len(*maxHeap) == 0
+	fmt.Printf("ヒープが空か %t\n", isEmpty)
+}
+
+func TestMyHeap(t *testing.T) {
+	/* ヒープを初期化 */
+	// 最大ヒープを初期化
+	maxHeap := newMaxHeap([]any{9, 8, 6, 6, 7, 5, 2, 1, 4, 3, 6, 2})
+	fmt.Printf("入力配列からヒープを構築した後\n")
+	maxHeap.print()
+
+	/* ヒープ頂点の要素を取得 */
+	peek := maxHeap.peek()
+	fmt.Printf("\nヒープ先頭要素は %d\n", peek)
+
+	/* 要素をヒープに追加 */
+	val := 7
+	maxHeap.push(val)
+	fmt.Printf("\n要素 %d をヒープに追加した後\n", val)
+	maxHeap.print()
+
+	/* ヒープ頂点の要素を取り出す */
+	peek = maxHeap.pop()
+	fmt.Printf("\nヒープ先頭要素 %d を取り出した後\n", peek)
+	maxHeap.print()
+
+	/* ヒープのサイズを取得 */
+	size := maxHeap.size()
+	fmt.Printf("\nヒープの要素数は %d\n", size)
+
+	/* ヒープが空かどうかを判定 */
+	isEmpty := maxHeap.isEmpty()
+	fmt.Printf("\nヒープが空か %t\n", isEmpty)
+}
+
+func TestTopKHeap(t *testing.T) {
+	/* ヒープを初期化 */
+	// 最大ヒープを初期化
+	nums := []int{1, 7, 6, 3, 2}
+	k := 3
+	res := topKHeap(nums, k)
+	fmt.Printf("最大の " + strconv.Itoa(k) + " 個の要素は")
+	PrintHeap(*res)
+}

ja/codes/go/chapter_heap/my_heap.go

@@ -0,0 +1,140 @@
+// File: my_heap.go
+// Created Time: 2023-01-12
+// Author: Reanon (793584285@qq.com)
+
+package chapter_heap
+
+import (
+	"fmt"
+
+	. "github.com/krahets/hello-algo/pkg"
+)
+
+type maxHeap struct {
+	// 配列ではなくスライスを使うことで、拡張を考慮せずに済む
+	data []any
+}
+
+/* コンストラクタ。空のヒープを作成する */
+func newHeap() *maxHeap {
+	return &maxHeap{
+		data: make([]any, 0),
+	}
+}
+
+/* コンストラクタ。スライスからヒープを構築する */
+func newMaxHeap(nums []any) *maxHeap {
+	// リスト要素をそのままヒープに追加
+	h := &maxHeap{data: nums}
+	for i := h.parent(len(h.data) - 1); i >= 0; i-- {
+		// 葉ノード以外のすべてのノードをヒープ化
+		h.siftDown(i)
+	}
+	return h
+}
+
+/* 左子ノードのインデックスを取得 */
+func (h *maxHeap) left(i int) int {
+	return 2*i + 1
+}
+
+/* 右子ノードのインデックスを取得 */
+func (h *maxHeap) right(i int) int {
+	return 2*i + 2
+}
+
+/* 親ノードのインデックスを取得 */
+func (h *maxHeap) parent(i int) int {
+	// 切り捨て除算
+	return (i - 1) / 2
+}
+
+/* 要素を交換 */
+func (h *maxHeap) swap(i, j int) {
+	h.data[i], h.data[j] = h.data[j], h.data[i]
+}
+
+/* ヒープのサイズを取得 */
+func (h *maxHeap) size() int {
+	return len(h.data)
+}
+
+/* ヒープが空かどうかを判定 */
+func (h *maxHeap) isEmpty() bool {
+	return len(h.data) == 0
+}
+
+/* ヒープ先頭要素にアクセス */
+func (h *maxHeap) peek() any {
+	return h.data[0]
+}
+
+/* 要素をヒープに追加 */
+func (h *maxHeap) push(val any) {
+	// ノードを追加
+	h.data = append(h.data, val)
+	// 下から上へヒープ化
+	h.siftUp(len(h.data) - 1)
+}
+
+/* ノード i から始めて、下から上へヒープ化 */
+func (h *maxHeap) siftUp(i int) {
+	for true {
+		// ノード i の親ノードを取得
+		p := h.parent(i)
+		// 「根ノードを越えた」または「ノードの修復が不要」になったらヒープ化を終了
+		if p < 0 || h.data[i].(int) <= h.data[p].(int) {
+			break
+		}
+		// 2 つのノードを交換
+		h.swap(i, p)
+		// ループで下から上へヒープ化
+		i = p
+	}
+}
+
+/* 要素をヒープから取り出す */
+func (h *maxHeap) pop() any {
+	// 空判定の処理
+	if h.isEmpty() {
+		fmt.Println("error")
+		return nil
+	}
+	// 根ノードと最も右の葉ノードを交換（先頭要素と末尾要素を交換）
+	h.swap(0, h.size()-1)
+	// ノードを削除
+	val := h.data[len(h.data)-1]
+	h.data = h.data[:len(h.data)-1]
+	// 上から下へヒープ化
+	h.siftDown(0)
+
+	// ヒープ先頭要素を返す
+	return val
+}
+
+/* ノード i から始めて、上から下へヒープ化 */
+func (h *maxHeap) siftDown(i int) {
+	for true {
+		// ノード i, l, r のうち値が最大のノードを max とする
+		l, r, max := h.left(i), h.right(i), i
+		if l < h.size() && h.data[l].(int) > h.data[max].(int) {
+			max = l
+		}
+		if r < h.size() && h.data[r].(int) > h.data[max].(int) {
+			max = r
+		}
+		// ノード i が最大、またはインデックス l, r が範囲外なら、ヒープ化は不要なので抜ける
+		if max == i {
+			break
+		}
+		// 2 つのノードを交換
+		h.swap(i, max)
+		// ループで上から下へヒープ化
+		i = max
+	}
+}
+
+/* ヒープ（二分木）を出力 */
+func (h *maxHeap) print() {
+	PrintHeap(h.data)
+}

ja/codes/go/chapter_heap/top_k.go

@@ -0,0 +1,51 @@
+// File: top_k.go
+// Created Time: 2023-06-24
+// Author: Reanon (793584285@qq.com)
+
+package chapter_heap
+
+import "container/heap"
+
+type minHeap []any
+
+func (h *minHeap) Len() int           { return len(*h) }
+func (h *minHeap) Less(i, j int) bool { return (*h)[i].(int) < (*h)[j].(int) }
+func (h *minHeap) Swap(i, j int)      { (*h)[i], (*h)[j] = (*h)[j], (*h)[i] }
+
+// Push は heap.Interface のメソッドで、要素をヒープに追加する
+func (h *minHeap) Push(x any) {
+	*h = append(*h, x.(int))
+}
+
+// Pop は heap.Interface のメソッドで、ヒープの先頭要素を取り出す
+func (h *minHeap) Pop() any {
+	// ヒープから取り出す要素を末尾に置く
+	last := (*h)[len(*h)-1]
+	*h = (*h)[:len(*h)-1]
+	return last
+}
+
+// Top ヒープ先頭要素を取得
+func (h *minHeap) Top() any {
+	return (*h)[0]
+}
+
+/* ヒープに基づいて配列中の最大の k 個の要素を探す */
+func topKHeap(nums []int, k int) *minHeap {
+	// 最小ヒープを初期化
+	h := &minHeap{}
+	heap.Init(h)
+	// 配列の先頭 k 個の要素をヒープに追加
+	for i := 0; i < k; i++ {
+		heap.Push(h, nums[i])
+	}
+	// k+1 番目の要素から開始し、ヒープ長を k に保つ
+	for i := k; i < len(nums); i++ {
+		// 現在の要素がヒープ先頭より大きければ、ヒープ先頭を取り出して現在の要素を追加する
+		if nums[i] > h.Top().(int) {
+			heap.Pop(h)
+			heap.Push(h, nums[i])
+		}
+	}
+	return h
+}