Add ru version (#1865)

* Add Russian docs site baseline

* Add Russian localized codebase

* Polish Russian code wording

* Update ru code translation.

* Update code translation and chapter covers.

* Fix pythontutor extraction.

* Add README and landing page.

* placeholder of profiles

* Use figures of English version

* Remove chapter paperbook

ru/codes/go/chapter_array_and_linkedlist/array.go

@@ -0,0 +1,79 @@
+// File: array.go
+// Created Time: 2022-12-29
+// Author: GuoWei (gongguowei01@gmail.com), cathay (cathaycchen@gmail.com)
+
+package chapter_array_and_linkedlist
+
+import (
+	"math/rand"
+)
+
+/* Случайный доступ к элементу */
+func randomAccess(nums []int) (randomNum int) {
+	// Случайным образом выбрать число из интервала [0, nums.length)
+	randomIndex := rand.Intn(len(nums))
+	// Получить и вернуть случайный элемент
+	randomNum = nums[randomIndex]
+	return
+}
+
+/* Увеличить длину массива */
+func extend(nums []int, enlarge int) []int {
+	// Инициализировать массив увеличенной длины
+	res := make([]int, len(nums)+enlarge)
+	// Скопировать все элементы исходного массива в новый массив
+	for i, num := range nums {
+		res[i] = num
+	}
+	// Вернуть новый массив после расширения
+	return res
+}
+
+/* Вставить элемент num по индексу index в массив */
+func insert(nums []int, num int, index int) {
+	// Сдвинуть элемент с индексом index и все последующие элементы на одну позицию назад
+	for i := len(nums) - 1; i > index; i-- {
+		nums[i] = nums[i-1]
+	}
+	// Присвоить num элементу по индексу index
+	nums[index] = num
+}
+
+/* Удалить элемент по индексу index */
+func remove(nums []int, index int) {
+	// Сдвинуть все элементы после индекса index на одну позицию вперед
+	for i := index; i < len(nums)-1; i++ {
+		nums[i] = nums[i+1]
+	}
+}
+
+/* Обход массива */
+func traverse(nums []int) {
+	count := 0
+	// Обход массива по индексам
+	for i := 0; i < len(nums); i++ {
+		count += nums[i]
+	}
+	count = 0
+	// Непосредственно обходить элементы массива
+	for _, num := range nums {
+		count += num
+	}
+	// Одновременно обходить индексы и элементы данных
+	for i, num := range nums {
+		count += nums[i]
+		count += num
+	}
+}
+
+/* Найти заданный элемент в массиве */
+func find(nums []int, target int) (index int) {
+	index = -1
+	for i := 0; i < len(nums); i++ {
+		if nums[i] == target {
+			index = i
+			break
+		}
+	}
+	return
+}

ru/codes/go/chapter_array_and_linkedlist/array_test.go

@@ -0,0 +1,50 @@
+// File: array_test.go
+// Created Time: 2022-12-29
+// Author: GuoWei (gongguowei01@gmail.com), cathay (cathaycchen@gmail.com)
+
+package chapter_array_and_linkedlist
+
+/**
+ * Мы рассматриваем срез Slice в Go как массив Array. Это позволяет
+ * снизить порог понимания и сосредоточиться на структурах данных и алгоритмах.
+ */
+
+import (
+	"fmt"
+	"testing"
+)
+
+/* Driver Code */
+func TestArray(t *testing.T) {
+	/* Инициализация массива */
+	var arr [5]int
+	fmt.Println("Массив arr =", arr)
+	// В Go при указании длины ([5]int) получается массив, а без указания длины ([]int) — срез
+	// Так как массивы в Go имеют длину, определяемую на этапе компиляции, для задания длины можно использовать только константы
+	// Для удобства реализации функции расширения extend() ниже срез (Slice) рассматривается как массив (Array)
+	nums := []int{1, 3, 2, 5, 4}
+	fmt.Println("Массив nums =", nums)
+
+	/* Случайный доступ */
+	randomNum := randomAccess(nums)
+	fmt.Println("Случайный элемент из nums =", randomNum)
+
+	/* Расширение длины */
+	nums = extend(nums, 3)
+	fmt.Println("После увеличения длины массива до 8 nums =", nums)
+
+	/* Вставка элемента */
+	insert(nums, 6, 3)
+	fmt.Println("После вставки числа 6 по индексу 3 nums =", nums)
+
+	/* Удаление элемента */
+	remove(nums, 2)
+	fmt.Println("После удаления элемента по индексу 2 nums =", nums)
+
+	/* Обход массива */
+	traverse(nums)
+
+	/* Поиск элемента */
+	index := find(nums, 3)
+	fmt.Println("Поиск элемента 3 в nums: индекс =", index)
+}

ru/codes/go/chapter_array_and_linkedlist/linked_list.go

@@ -0,0 +1,51 @@
+// File: linked_list.go
+// Created Time: 2022-12-29
+// Author: cathay (cathaycchen@gmail.com)
+
+package chapter_array_and_linkedlist
+
+import (
+	. "github.com/krahets/hello-algo/pkg"
+)
+
+/* Вставить узел P после узла n0 в связном списке */
+func insertNode(n0 *ListNode, P *ListNode) {
+	n1 := n0.Next
+	P.Next = n1
+	n0.Next = P
+}
+
+/* Удалить первый узел после узла n0 в связном списке */
+func removeItem(n0 *ListNode) {
+	if n0.Next == nil {
+		return
+	}
+	// n0 -> P -> n1
+	P := n0.Next
+	n1 := P.Next
+	n0.Next = n1
+}
+
+/* Доступ к узлу связного списка по индексу index */
+func access(head *ListNode, index int) *ListNode {
+	for i := 0; i < index; i++ {
+		if head == nil {
+			return nil
+		}
+		head = head.Next
+	}
+	return head
+}
+
+/* Найти в связном списке первый узел со значением target */
+func findNode(head *ListNode, target int) int {
+	index := 0
+	for head != nil {
+		if head.Val == target {
+			return index
+		}
+		head = head.Next
+		index++
+	}
+	return -1
+}

ru/codes/go/chapter_array_and_linkedlist/linked_list_test.go

@@ -0,0 +1,48 @@
+// File: linked_list_test.go
+// Created Time: 2022-12-29
+// Author: cathay (cathaycchen@gmail.com)
+
+package chapter_array_and_linkedlist
+
+import (
+	"fmt"
+	"testing"
+
+	. "github.com/krahets/hello-algo/pkg"
+)
+
+func TestLinkedList(t *testing.T) {
+	/* Инициализировать связный список 1 -> 3 -> 2 -> 5 -> 4 */
+	// Инициализация всех узлов
+	n0 := NewListNode(1)
+	n1 := NewListNode(3)
+	n2 := NewListNode(2)
+	n3 := NewListNode(5)
+	n4 := NewListNode(4)
+
+	// Построить ссылки между узлами
+	n0.Next = n1
+	n1.Next = n2
+	n2.Next = n3
+	n3.Next = n4
+	fmt.Println("Исходный связный список")
+	PrintLinkedList(n0)
+
+	/* Вставка узла */
+	insertNode(n0, NewListNode(0))
+	fmt.Println("Связный список после вставки узла")
+	PrintLinkedList(n0)
+
+	/* Удаление узла */
+	removeItem(n0)
+	fmt.Println("Связный список после удаления узла")
+	PrintLinkedList(n0)
+
+	/* Доступ к узлу */
+	node := access(n0, 3)
+	fmt.Println("Значение узла по индексу 3 в связном списке =", node)
+
+	/* Поиск узла */
+	index := findNode(n0, 2)
+	fmt.Println("Индекс узла со значением 2 в связном списке =", index)
+}

ru/codes/go/chapter_array_and_linkedlist/list_test.go

@@ -0,0 +1,66 @@
+// File: list_test.go
+// Created Time: 2022-12-18
+// Author: msk397 (machangxinq@gmail.com)
+
+package chapter_array_and_linkedlist
+
+import (
+	"fmt"
+	"sort"
+	"testing"
+)
+
+/* Driver Code */
+func TestList(t *testing.T) {
+	/* Инициализация списка */
+	nums := []int{1, 3, 2, 5, 4}
+	fmt.Println("Список nums =", nums)
+
+	/* Доступ к элементу */
+	num := nums[1] // Обратиться к элементу по индексу 1
+	fmt.Println("Элемент по индексу 1: num =", num)
+
+	/* Обновление элемента */
+	nums[1] = 0 // Обновить элемент по индексу 1 до 0
+	fmt.Println("После обновления элемента по индексу 1 до 0 nums =", nums)
+
+	/* Очистить список */
+	nums = nil
+	fmt.Println("После очистки списка nums =", nums)
+
+	/* Добавление элемента в конец */
+	nums = append(nums, 1)
+	nums = append(nums, 3)
+	nums = append(nums, 2)
+	nums = append(nums, 5)
+	nums = append(nums, 4)
+	fmt.Println("После добавления элементов nums =", nums)
+
+	/* Вставка элемента в середину */
+	nums = append(nums[:3], append([]int{6}, nums[3:]...)...) // Вставить число 6 по индексу 3
+	fmt.Println("После вставки числа 6 по индексу 3 nums =", nums)
+
+	/* Удаление элемента */
+	nums = append(nums[:3], nums[4:]...) // Удалить элемент по индексу 3
+	fmt.Println("После удаления элемента по индексу 3 nums =", nums)
+
+	/* Обходить список по индексам */
+	count := 0
+	for i := 0; i < len(nums); i++ {
+		count += nums[i]
+	}
+	/* Непосредственно обходить элементы списка */
+	count = 0
+	for _, x := range nums {
+		count += x
+	}
+
+	/* Объединить два списка */
+	nums1 := []int{6, 8, 7, 10, 9}
+	nums = append(nums, nums1...) // Присоединить список nums1 после nums
+	fmt.Println("После конкатенации списка nums1 к nums nums =", nums)
+
+	/* Отсортировать список */
+	sort.Ints(nums) // После сортировки элементы списка располагаются по возрастанию
+	fmt.Println("После сортировки списка nums =", nums)
+}

ru/codes/go/chapter_array_and_linkedlist/my_list.go

@@ -0,0 +1,109 @@
+// File: my_list.go
+// Created Time: 2022-12-18
+// Author: msk397 (machangxinq@gmail.com)
+
+package chapter_array_and_linkedlist
+
+/* Класс списка */
+type myList struct {
+	arrCapacity int
+	arr         []int
+	arrSize     int
+	extendRatio int
+}
+
+/* Конструктор */
+func newMyList() *myList {
+	return &myList{
+		arrCapacity: 10,              // Вместимость списка
+		arr:         make([]int, 10), // Массив (для хранения элементов списка)
+		arrSize:     0,               // Длина списка (текущее число элементов)
+		extendRatio: 2,               // Коэффициент увеличения списка при каждом расширении
+	}
+}
+
+/* Получить длину списка (текущее число элементов) */
+func (l *myList) size() int {
+	return l.arrSize
+}
+
+/* Получить вместимость списка */
+func (l *myList) capacity() int {
+	return l.arrCapacity
+}
+
+/* Доступ к элементу */
+func (l *myList) get(index int) int {
+	// Если индекс выходит за границы, выбрасывается исключение; далее аналогично
+	if index < 0 || index >= l.arrSize {
+		panic("индекс выходит за границы")
+	}
+	return l.arr[index]
+}
+
+/* Обновление элемента */
+func (l *myList) set(num, index int) {
+	if index < 0 || index >= l.arrSize {
+		panic("индекс выходит за границы")
+	}
+	l.arr[index] = num
+}
+
+/* Добавление элемента в конец */
+func (l *myList) add(num int) {
+	// При превышении вместимости по числу элементов запускается расширение
+	if l.arrSize == l.arrCapacity {
+		l.extendCapacity()
+	}
+	l.arr[l.arrSize] = num
+	// Обновить число элементов
+	l.arrSize++
+}
+
+/* Вставка элемента в середину */
+func (l *myList) insert(num, index int) {
+	if index < 0 || index >= l.arrSize {
+		panic("индекс выходит за границы")
+	}
+	// При превышении вместимости по числу элементов запускается расширение
+	if l.arrSize == l.arrCapacity {
+		l.extendCapacity()
+	}
+	// Сдвинуть элемент с индексом index и все следующие элементы на одну позицию назад
+	for j := l.arrSize - 1; j >= index; j-- {
+		l.arr[j+1] = l.arr[j]
+	}
+	l.arr[index] = num
+	// Обновить число элементов
+	l.arrSize++
+}
+
+/* Удаление элемента */
+func (l *myList) remove(index int) int {
+	if index < 0 || index >= l.arrSize {
+		panic("индекс выходит за границы")
+	}
+	num := l.arr[index]
+	// Сдвинуть все элементы после индекса index на одну позицию вперед
+	for j := index; j < l.arrSize-1; j++ {
+		l.arr[j] = l.arr[j+1]
+	}
+	// Обновить число элементов
+	l.arrSize--
+	// Вернуть удаленный элемент
+	return num
+}
+
+/* Расширение списка */
+func (l *myList) extendCapacity() {
+	// Создать новый массив длиной в extendRatio раз больше исходного и скопировать в него исходный массив
+	l.arr = append(l.arr, make([]int, l.arrCapacity*(l.extendRatio-1))...)
+	// Обновить вместимость списка
+	l.arrCapacity = len(l.arr)
+}
+
+/* Вернуть список фактической длины */
+func (l *myList) toArray() []int {
+	// Преобразовывать только элементы списка в пределах фактической длины
+	return l.arr[:l.arrSize]
+}

ru/codes/go/chapter_array_and_linkedlist/my_list_test.go

@@ -0,0 +1,46 @@
+// File: my_list_test.go
+// Created Time: 2022-12-18
+// Author: msk397 (machangxinq@gmail.com)
+
+package chapter_array_and_linkedlist
+
+import (
+	"fmt"
+	"testing"
+)
+
+/* Driver Code */
+func TestMyList(t *testing.T) {
+	/* Инициализация списка */
+	nums := newMyList()
+	/* Добавление элемента в конец */
+	nums.add(1)
+	nums.add(3)
+	nums.add(2)
+	nums.add(5)
+	nums.add(4)
+	fmt.Printf("Список nums = %v, вместимость = %v, длина = %v\n", nums.toArray(), nums.capacity(), nums.size())
+
+	/* Вставка элемента в середину */
+	nums.insert(6, 3)
+	fmt.Printf("После вставки числа 6 по индексу 3 nums = %v\n", nums.toArray())
+
+	/* Удаление элемента */
+	nums.remove(3)
+	fmt.Printf("После удаления элемента по индексу 3 nums = %v\n", nums.toArray())
+
+	/* Доступ к элементу */
+	num := nums.get(1)
+	fmt.Printf("Элемент по индексу 1: num = %v\n", num)
+
+	/* Обновление элемента */
+	nums.set(0, 1)
+	fmt.Printf("После обновления элемента по индексу 1 до 0 nums = %v\n", nums.toArray())
+
+	/* Проверка механизма расширения */
+	for i := 0; i < 10; i++ {
+		// При i = 5 длина списка превысит его вместимость, и в этот момент сработает механизм расширения
+		nums.add(i)
+	}
+	fmt.Printf("Список nums после увеличения вместимости = %v, вместимость = %v, длина = %v\n", nums.toArray(), nums.capacity(), nums.size())
+}

ru/codes/go/chapter_backtracking/n_queens.go

@@ -0,0 +1,57 @@
+// File: n_queens.go
+// Created Time: 2023-05-09
+// Author: Reanon (793584285@qq.com)
+
+package chapter_backtracking
+
+/* Алгоритм бэктрекинга: n ферзей */
+func backtrack(row, n int, state *[][]string, res *[][][]string, cols, diags1, diags2 *[]bool) {
+	// Когда все строки уже обработаны, записать решение
+	if row == n {
+		newState := make([][]string, len(*state))
+		for i, _ := range newState {
+			newState[i] = make([]string, len((*state)[0]))
+			copy(newState[i], (*state)[i])
+
+		}
+		*res = append(*res, newState)
+		return
+	}
+	// Обойти все столбцы
+	for col := 0; col < n; col++ {
+		// Вычислить главную и побочную диагонали, соответствующие этой клетке
+		diag1 := row - col + n - 1
+		diag2 := row + col
+		// Отсечение: в столбце, главной диагонали и побочной диагонали этой клетки не должно быть ферзей
+		if !(*cols)[col] && !(*diags1)[diag1] && !(*diags2)[diag2] {
+			// Попытка: поставить ферзя в эту клетку
+			(*state)[row][col] = "Q"
+			(*cols)[col], (*diags1)[diag1], (*diags2)[diag2] = true, true, true
+			// Перейти к размещению следующей строки
+			backtrack(row+1, n, state, res, cols, diags1, diags2)
+			// Откат: восстановить эту клетку как пустую
+			(*state)[row][col] = "#"
+			(*cols)[col], (*diags1)[diag1], (*diags2)[diag2] = false, false, false
+		}
+	}
+}
+
+/* Решить задачу о n ферзях */
+func nQueens(n int) [][][]string {
+	// Инициализировать доску размера n*n, где 'Q' обозначает ферзя, а '#' — пустую клетку
+	state := make([][]string, n)
+	for i := 0; i < n; i++ {
+		row := make([]string, n)
+		for i := 0; i < n; i++ {
+			row[i] = "#"
+		}
+		state[i] = row
+	}
+	// Отмечать, есть ли ферзь в столбце
+	cols := make([]bool, n)
+	diags1 := make([]bool, 2*n-1)
+	diags2 := make([]bool, 2*n-1)
+	res := make([][][]string, 0)
+	backtrack(0, n, &state, &res, &cols, &diags1, &diags2)
+	return res
+}

ru/codes/go/chapter_backtracking/n_queens_test.go

@@ -0,0 +1,24 @@
+// File: n_queens_test.go
+// Created Time: 2023-05-14
+// Author: Reanon (793584285@qq.com)
+
+package chapter_backtracking
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestNQueens(t *testing.T) {
+	n := 4
+	res := nQueens(n)
+
+	fmt.Println("Размер входной доски =", n)
+	fmt.Println("Количество способов расстановки ферзей:", len(res))
+	for _, state := range res {
+		fmt.Println("--------------------")
+		for _, row := range state {
+			fmt.Println(row)
+		}
+	}
+}

ru/codes/go/chapter_backtracking/permutation_test.go

@@ -0,0 +1,33 @@
+// File: permutation_test.go
+// Created Time: 2023-05-09
+// Author: Reanon (793584285@qq.com)
+
+package chapter_backtracking
+
+import (
+	"fmt"
+	"testing"
+
+	. "github.com/krahets/hello-algo/pkg"
+)
+
+func TestPermutationI(t *testing.T) {
+	/* Все перестановки I */
+	nums := []int{1, 2, 3}
+	fmt.Printf("Входной массив nums = ")
+	PrintSlice(nums)
+
+	res := permutationsI(nums)
+	fmt.Printf("Все перестановки res = ")
+	fmt.Println(res)
+}
+
+func TestPermutationII(t *testing.T) {
+	nums := []int{1, 2, 2}
+	fmt.Printf("Входной массив nums = ")
+	PrintSlice(nums)
+
+	res := permutationsII(nums)
+	fmt.Printf("Все перестановки res = ")
+	fmt.Println(res)
+}

ru/codes/go/chapter_backtracking/permutations_i.go

@@ -0,0 +1,38 @@
+// File: permutations_i.go
+// Created Time: 2023-05-14
+// Author: Reanon (793584285@qq.com)
+
+package chapter_backtracking
+
+/* Алгоритм бэктрекинга: все перестановки I */
+func backtrackI(state *[]int, choices *[]int, selected *[]bool, res *[][]int) {
+	// Когда длина состояния равна числу элементов, записать решение
+	if len(*state) == len(*choices) {
+		newState := append([]int{}, *state...)
+		*res = append(*res, newState)
+	}
+	// Перебор всех вариантов выбора
+	for i := 0; i < len(*choices); i++ {
+		choice := (*choices)[i]
+		// Отсечение: нельзя выбирать один и тот же элемент повторно
+		if !(*selected)[i] {
+			// Попытка: сделать выбор и обновить состояние
+			(*selected)[i] = true
+			*state = append(*state, choice)
+			// Перейти к следующему выбору
+			backtrackI(state, choices, selected, res)
+			// Откат: отменить выбор и восстановить предыдущее состояние
+			(*selected)[i] = false
+			*state = (*state)[:len(*state)-1]
+		}
+	}
+}
+
+/* Все перестановки I */
+func permutationsI(nums []int) [][]int {
+	res := make([][]int, 0)
+	state := make([]int, 0)
+	selected := make([]bool, len(nums))
+	backtrackI(&state, &nums, &selected, &res)
+	return res
+}

ru/codes/go/chapter_backtracking/permutations_ii.go

@@ -0,0 +1,41 @@
+// File: permutations_ii.go
+// Created Time: 2023-05-14
+// Author: Reanon (793584285@qq.com)
+
+package chapter_backtracking
+
+/* Алгоритм бэктрекинга: все перестановки II */
+func backtrackII(state *[]int, choices *[]int, selected *[]bool, res *[][]int) {
+	// Когда длина состояния равна числу элементов, записать решение
+	if len(*state) == len(*choices) {
+		newState := append([]int{}, *state...)
+		*res = append(*res, newState)
+	}
+	// Перебор всех вариантов выбора
+	duplicated := make(map[int]struct{}, 0)
+	for i := 0; i < len(*choices); i++ {
+		choice := (*choices)[i]
+		// Отсечение: нельзя выбирать один и тот же элемент повторно и нельзя повторно выбирать равные элементы
+		if _, ok := duplicated[choice]; !ok && !(*selected)[i] {
+			// Попробовать: сделать выбор, обновить состояние
+			// Записать значение уже выбранного элемента
+			duplicated[choice] = struct{}{}
+			(*selected)[i] = true
+			*state = append(*state, choice)
+			// Перейти к следующему выбору
+			backtrackII(state, choices, selected, res)
+			// Откат: отменить выбор и восстановить предыдущее состояние
+			(*selected)[i] = false
+			*state = (*state)[:len(*state)-1]
+		}
+	}
+}
+
+/* Все перестановки II */
+func permutationsII(nums []int) [][]int {
+	res := make([][]int, 0)
+	state := make([]int, 0)
+	selected := make([]bool, len(nums))
+	backtrackII(&state, &nums, &selected, &res)
+	return res
+}

ru/codes/go/chapter_backtracking/preorder_traversal_i_compact.go

@@ -0,0 +1,22 @@
+// File: preorder_traversal_i_compact.go
+// Created Time: 2023-05-09
+// Author: Reanon (793584285@qq.com)
+
+package chapter_backtracking
+
+import (
+	. "github.com/krahets/hello-algo/pkg"
+)
+
+/* Предварительный обход: пример 1 */
+func preOrderI(root *TreeNode, res *[]*TreeNode) {
+	if root == nil {
+		return
+	}
+	if (root.Val).(int) == 7 {
+		// Записать решение
+		*res = append(*res, root)
+	}
+	preOrderI(root.Left, res)
+	preOrderI(root.Right, res)
+}

ru/codes/go/chapter_backtracking/preorder_traversal_ii_compact.go

@@ -0,0 +1,26 @@
+// File: preorder_traversal_ii_compact.go
+// Created Time: 2023-05-09
+// Author: Reanon (793584285@qq.com)
+
+package chapter_backtracking
+
+import (
+	. "github.com/krahets/hello-algo/pkg"
+)
+
+/* Предварительный обход: пример 2 */
+func preOrderII(root *TreeNode, res *[][]*TreeNode, path *[]*TreeNode) {
+	if root == nil {
+		return
+	}
+	// Попытка
+	*path = append(*path, root)
+	if root.Val.(int) == 7 {
+		// Записать решение
+		*res = append(*res, append([]*TreeNode{}, *path...))
+	}
+	preOrderII(root.Left, res, path)
+	preOrderII(root.Right, res, path)
+	// Откат
+	*path = (*path)[:len(*path)-1]
+}

ru/codes/go/chapter_backtracking/preorder_traversal_iii_compact.go

@@ -0,0 +1,27 @@
+// File: preorder_traversal_iii_compact.go
+// Created Time: 2023-05-09
+// Author: Reanon (793584285@qq.com)
+
+package chapter_backtracking
+
+import (
+	. "github.com/krahets/hello-algo/pkg"
+)
+
+/* Предварительный обход: пример 3 */
+func preOrderIII(root *TreeNode, res *[][]*TreeNode, path *[]*TreeNode) {
+	// Отсечение
+	if root == nil || root.Val == 3 {
+		return
+	}
+	// Попытка
+	*path = append(*path, root)
+	if root.Val.(int) == 7 {
+		// Записать решение
+		*res = append(*res, append([]*TreeNode{}, *path...))
+	}
+	preOrderIII(root.Left, res, path)
+	preOrderIII(root.Right, res, path)
+	// Откат
+	*path = (*path)[:len(*path)-1]
+}

ru/codes/go/chapter_backtracking/preorder_traversal_iii_template.go

@@ -0,0 +1,57 @@
+// File: preorder_traversal_iii_template.go
+// Created Time: 2023-05-09
+// Author: Reanon (793584285@qq.com)
+
+package chapter_backtracking
+
+import (
+	. "github.com/krahets/hello-algo/pkg"
+)
+
+/* Проверить, является ли текущее состояние решением */
+func isSolution(state *[]*TreeNode) bool {
+	return len(*state) != 0 && (*state)[len(*state)-1].Val == 7
+}
+
+/* Записать решение */
+func recordSolution(state *[]*TreeNode, res *[][]*TreeNode) {
+	*res = append(*res, append([]*TreeNode{}, *state...))
+}
+
+/* Проверить, допустим ли этот выбор в текущем состоянии */
+func isValid(state *[]*TreeNode, choice *TreeNode) bool {
+	return choice != nil && choice.Val != 3
+}
+
+/* Обновить состояние */
+func makeChoice(state *[]*TreeNode, choice *TreeNode) {
+	*state = append(*state, choice)
+}
+
+/* Восстановить состояние */
+func undoChoice(state *[]*TreeNode, choice *TreeNode) {
+	*state = (*state)[:len(*state)-1]
+}
+
+/* Алгоритм бэктрекинга: пример 3 */
+func backtrackIII(state *[]*TreeNode, choices *[]*TreeNode, res *[][]*TreeNode) {
+	// Проверить, является ли текущее состояние решением
+	if isSolution(state) {
+		// Записать решение
+		recordSolution(state, res)
+	}
+	// Перебор всех вариантов выбора
+	for _, choice := range *choices {
+		// Отсечение: проверить допустимость выбора
+		if isValid(state, choice) {
+			// Попытка: сделать выбор и обновить состояние
+			makeChoice(state, choice)
+			// Перейти к следующему выбору
+			temp := make([]*TreeNode, 0)
+			temp = append(temp, choice.Left, choice.Right)
+			backtrackIII(state, &temp, res)
+			// Откат: отменить выбор и восстановить предыдущее состояние
+			undoChoice(state, choice)
+		}
+	}
+}

ru/codes/go/chapter_backtracking/preorder_traversal_test.go

@@ -0,0 +1,91 @@
+// File: preorder_traversal_i_compact_test.go
+// Created Time: 2023-05-09
+// Author: Reanon (793584285@qq.com)
+
+package chapter_backtracking
+
+import (
+	"fmt"
+	"testing"
+
+	. "github.com/krahets/hello-algo/pkg"
+)
+
+func TestPreorderTraversalICompact(t *testing.T) {
+	/* Инициализация двоичного дерева */
+	root := SliceToTree([]any{1, 7, 3, 4, 5, 6, 7})
+	fmt.Println("\nИнициализация двоичного дерева")
+	PrintTree(root)
+
+	// Предварительный обход
+	res := make([]*TreeNode, 0)
+	preOrderI(root, &res)
+
+	fmt.Println("\nВсе узлы со значением 7")
+	for _, node := range res {
+		fmt.Printf("%v ", node.Val)
+	}
+	fmt.Println()
+}
+
+func TestPreorderTraversalIICompact(t *testing.T) {
+	/* Инициализация двоичного дерева */
+	root := SliceToTree([]any{1, 7, 3, 4, 5, 6, 7})
+	fmt.Println("\nИнициализация двоичного дерева")
+	PrintTree(root)
+
+	// Предварительный обход
+	path := make([]*TreeNode, 0)
+	res := make([][]*TreeNode, 0)
+	preOrderII(root, &res, &path)
+
+	fmt.Println("\nВсе пути от корня к узлу 7")
+	for _, path := range res {
+		for _, node := range path {
+			fmt.Printf("%v ", node.Val)
+		}
+		fmt.Println()
+	}
+}
+
+func TestPreorderTraversalIIICompact(t *testing.T) {
+	/* Инициализация двоичного дерева */
+	root := SliceToTree([]any{1, 7, 3, 4, 5, 6, 7})
+	fmt.Println("\nИнициализация двоичного дерева")
+	PrintTree(root)
+
+	// Предварительный обход
+	path := make([]*TreeNode, 0)
+	res := make([][]*TreeNode, 0)
+	preOrderIII(root, &res, &path)
+
+	fmt.Println("\nВсе пути от корня к узлу 7, не содержащие узлов со значением 3")
+	for _, path := range res {
+		for _, node := range path {
+			fmt.Printf("%v ", node.Val)
+		}
+		fmt.Println()
+	}
+}
+
+func TestPreorderTraversalIIITemplate(t *testing.T) {
+	/* Инициализация двоичного дерева */
+	root := SliceToTree([]any{1, 7, 3, 4, 5, 6, 7})
+	fmt.Println("\nИнициализация двоичного дерева")
+	PrintTree(root)
+
+	// Алгоритм бэктрекинга
+	res := make([][]*TreeNode, 0)
+	state := make([]*TreeNode, 0)
+	choices := make([]*TreeNode, 0)
+	choices = append(choices, root)
+	backtrackIII(&state, &choices, &res)
+
+	fmt.Println("\nВсе пути от корня к узлу 7, не содержащие узлов со значением 3")
+	for _, path := range res {
+		for _, node := range path {
+			fmt.Printf("%v ", node.Val)
+		}
+		fmt.Println()
+	}
+}

ru/codes/go/chapter_backtracking/subset_sum_i.go

@@ -0,0 +1,42 @@
+// File: subset_sum_i.go
+// Created Time: 2023-06-24
+// Author: Reanon (793584285@qq.com)
+
+package chapter_backtracking
+
+import "sort"
+
+/* Алгоритм бэктрекинга: сумма подмножеств I */
+func backtrackSubsetSumI(start, target int, state, choices *[]int, res *[][]int) {
+	// Если сумма подмножества равна target, записать решение
+	if target == 0 {
+		newState := append([]int{}, *state...)
+		*res = append(*res, newState)
+		return
+	}
+	// Обойти все варианты выбора
+	// Отсечение 2: начинать обход с start, чтобы избежать генерации повторяющихся подмножеств
+	for i := start; i < len(*choices); i++ {
+		// Отсечение 1: если сумма подмножества превышает target, немедленно завершить цикл
+		// Это связано с тем, что массив уже отсортирован, следующие элементы больше, и сумма подмножества точно превысит target
+		if target-(*choices)[i] < 0 {
+			break
+		}
+		// Попытка: сделать выбор и обновить target и start
+		*state = append(*state, (*choices)[i])
+		// Перейти к следующему выбору
+		backtrackSubsetSumI(i, target-(*choices)[i], state, choices, res)
+		// Откат: отменить выбор и восстановить предыдущее состояние
+		*state = (*state)[:len(*state)-1]
+	}
+}
+
+/* Решить задачу суммы подмножеств I */
+func subsetSumI(nums []int, target int) [][]int {
+	state := make([]int, 0) // Состояние (подмножество)
+	sort.Ints(nums)         // Отсортировать nums
+	start := 0              // Стартовая вершина обхода
+	res := make([][]int, 0) // Список результатов (список подмножеств)
+	backtrackSubsetSumI(start, target, &state, &nums, &res)
+	return res
+}

ru/codes/go/chapter_backtracking/subset_sum_i_naive.go

@@ -0,0 +1,37 @@
+// File: subset_sum_i_naive.go
+// Created Time: 2023-06-24
+// Author: Reanon (793584285@qq.com)
+
+package chapter_backtracking
+
+/* Алгоритм бэктрекинга: сумма подмножеств I */
+func backtrackSubsetSumINaive(total, target int, state, choices *[]int, res *[][]int) {
+	// Если сумма подмножества равна target, записать решение
+	if target == total {
+		newState := append([]int{}, *state...)
+		*res = append(*res, newState)
+		return
+	}
+	// Перебор всех вариантов выбора
+	for i := 0; i < len(*choices); i++ {
+		// Отсечение: если сумма подмножества превышает target, пропустить этот выбор
+		if total+(*choices)[i] > target {
+			continue
+		}
+		// Попытка: сделать выбор и обновить элемент и total
+		*state = append(*state, (*choices)[i])
+		// Перейти к следующему выбору
+		backtrackSubsetSumINaive(total+(*choices)[i], target, state, choices, res)
+		// Откат: отменить выбор и восстановить предыдущее состояние
+		*state = (*state)[:len(*state)-1]
+	}
+}
+
+/* Решить задачу суммы подмножеств I (с повторяющимися подмножествами) */
+func subsetSumINaive(nums []int, target int) [][]int {
+	state := make([]int, 0) // Состояние (подмножество)
+	total := 0              // Сумма подмножеств
+	res := make([][]int, 0) // Список результатов (список подмножеств)
+	backtrackSubsetSumINaive(total, target, &state, &nums, &res)
+	return res
+}

ru/codes/go/chapter_backtracking/subset_sum_ii.go

@@ -0,0 +1,47 @@
+// File: subset_sum_ii.go
+// Created Time: 2023-06-24
+// Author: Reanon (793584285@qq.com)
+
+package chapter_backtracking
+
+import "sort"
+
+/* Алгоритм бэктрекинга: сумма подмножеств II */
+func backtrackSubsetSumII(start, target int, state, choices *[]int, res *[][]int) {
+	// Если сумма подмножества равна target, записать решение
+	if target == 0 {
+		newState := append([]int{}, *state...)
+		*res = append(*res, newState)
+		return
+	}
+	// Обойти все варианты выбора
+	// Отсечение 2: начинать обход с start, чтобы избежать генерации повторяющихся подмножеств
+	// Отсечение 3: начинать обход с start, чтобы избежать повторного выбора одного и того же элемента
+	for i := start; i < len(*choices); i++ {
+		// Отсечение 1: если сумма подмножества превышает target, немедленно завершить цикл
+		// Это связано с тем, что массив уже отсортирован, следующие элементы больше, и сумма подмножества точно превысит target
+		if target-(*choices)[i] < 0 {
+			break
+		}
+		// Отсечение 4: если этот элемент равен элементу слева, значит ветвь поиска повторяется, ее нужно сразу пропустить
+		if i > start && (*choices)[i] == (*choices)[i-1] {
+			continue
+		}
+		// Попытка: сделать выбор и обновить target и start
+		*state = append(*state, (*choices)[i])
+		// Перейти к следующему выбору
+		backtrackSubsetSumII(i+1, target-(*choices)[i], state, choices, res)
+		// Откат: отменить выбор и восстановить предыдущее состояние
+		*state = (*state)[:len(*state)-1]
+	}
+}
+
+/* Решить задачу суммы подмножеств II */
+func subsetSumII(nums []int, target int) [][]int {
+	state := make([]int, 0) // Состояние (подмножество)
+	sort.Ints(nums)         // Отсортировать nums
+	start := 0              // Стартовая вершина обхода
+	res := make([][]int, 0) // Список результатов (список подмножеств)
+	backtrackSubsetSumII(start, target, &state, &nums, &res)
+	return res
+}

ru/codes/go/chapter_backtracking/subset_sum_test.go

@@ -0,0 +1,56 @@
+// File: subset_sum_test.go
+// Created Time: 2023-06-24
+// Author: Reanon (793584285@qq.com)
+
+package chapter_backtracking
+
+import (
+	"fmt"
+	"strconv"
+	"testing"
+
+	. "github.com/krahets/hello-algo/pkg"
+)
+
+func TestSubsetSumINaive(t *testing.T) {
+	nums := []int{3, 4, 5}
+	target := 9
+	res := subsetSumINaive(nums, target)
+
+	fmt.Printf("target = " + strconv.Itoa(target) + ", входной массив nums = ")
+	PrintSlice(nums)
+
+	fmt.Println("Все подмножества с суммой " + strconv.Itoa(target) + ": res = ")
+	for i := range res {
+		PrintSlice(res[i])
+	}
+	fmt.Println("Обратите внимание: результат этого метода содержит повторяющиеся множества")
+}
+
+func TestSubsetSumI(t *testing.T) {
+	nums := []int{3, 4, 5}
+	target := 9
+	res := subsetSumI(nums, target)
+
+	fmt.Printf("target = " + strconv.Itoa(target) + ", входной массив nums = ")
+	PrintSlice(nums)
+
+	fmt.Println("Все подмножества с суммой " + strconv.Itoa(target) + ": res = ")
+	for i := range res {
+		PrintSlice(res[i])
+	}
+}
+
+func TestSubsetSumII(t *testing.T) {
+	nums := []int{4, 4, 5}
+	target := 9
+	res := subsetSumII(nums, target)
+
+	fmt.Printf("target = " + strconv.Itoa(target) + ", входной массив nums = ")
+	PrintSlice(nums)
+
+	fmt.Println("Все подмножества с суммой " + strconv.Itoa(target) + ": res = ")
+	for i := range res {
+		PrintSlice(res[i])
+	}
+}

ru/codes/go/chapter_computational_complexity/iteration.go

@@ -0,0 +1,59 @@
+// File: iteration.go
+// Created Time: 2023-08-28
+// Author: Reanon (793584285@qq.com)
+
+package chapter_computational_complexity
+
+import "fmt"
+
+/* Цикл for */
+func forLoop(n int) int {
+	res := 0
+	// Циклическое суммирование 1, 2, ..., n-1, n
+	for i := 1; i <= n; i++ {
+		res += i
+	}
+	return res
+}
+
+/* Цикл while */
+func whileLoop(n int) int {
+	res := 0
+	// Инициализация условной переменной
+	i := 1
+	// Циклическое суммирование 1, 2, ..., n-1, n
+	for i <= n {
+		res += i
+		// Обновить условную переменную
+		i++
+	}
+	return res
+}
+
+/* Цикл while (двойное обновление) */
+func whileLoopII(n int) int {
+	res := 0
+	// Инициализация условной переменной
+	i := 1
+	// Циклическое суммирование 1, 4, 10, ...
+	for i <= n {
+		res += i
+		// Обновить условную переменную
+		i++
+		i *= 2
+	}
+	return res
+}
+
+/* Двойной цикл for */
+func nestedForLoop(n int) string {
+	res := ""
+	// Цикл по i = 1, 2, ..., n-1, n
+	for i := 1; i <= n; i++ {
+		for j := 1; j <= n; j++ {
+			// Цикл по j = 1, 2, ..., n-1, n
+			res += fmt.Sprintf("(%d, %d), ", i, j)
+		}
+	}
+	return res
+}

ru/codes/go/chapter_computational_complexity/iteration_test.go

@@ -0,0 +1,26 @@
+// File: iteration_test.go
+// Created Time: 2023-08-28
+// Author: Reanon (793584285@qq.com)
+
+package chapter_computational_complexity
+
+import (
+	"fmt"
+	"testing"
+)
+
+/* Driver Code */
+func TestIteration(t *testing.T) {
+	n := 5
+	res := forLoop(n)
+	fmt.Println("\nРезультат суммирования в цикле for res = ", res)
+
+	res = whileLoop(n)
+	fmt.Println("\nРезультат суммирования в цикле while res = ", res)
+
+	res = whileLoopII(n)
+	fmt.Println("\nРезультат суммирования в цикле while (двойное обновление) res = ", res)
+
+	resStr := nestedForLoop(n)
+	fmt.Println("\nРезультат обхода в двойном цикле for ", resStr)
+}

ru/codes/go/chapter_computational_complexity/recursion.go

@@ -0,0 +1,61 @@
+// File: recursion.go
+// Created Time: 2023-08-28
+// Author: Reanon (793584285@qq.com)
+
+package chapter_computational_complexity
+
+import "container/list"
+
+/* Рекурсия */
+func recur(n int) int {
+	// Условие завершения
+	if n == 1 {
+		return 1
+	}
+	// Рекурсия: рекурсивный вызов
+	res := recur(n - 1)
+	// Возврат: вернуть результат
+	return n + res
+}
+
+/* Имитация рекурсии итерацией */
+func forLoopRecur(n int) int {
+	// Использовать явный стек для имитации системного стека вызовов
+	stack := list.New()
+	res := 0
+	// Рекурсия: рекурсивный вызов
+	for i := n; i > 0; i-- {
+		// Имитировать «рекурсию» с помощью операции помещения в стек
+		stack.PushBack(i)
+	}
+	// Возврат: вернуть результат
+	for stack.Len() != 0 {
+		// Имитировать «возврат» с помощью операции извлечения из стека
+		res += stack.Back().Value.(int)
+		stack.Remove(stack.Back())
+	}
+	// res = 1+2+3+...+n
+	return res
+}
+
+/* Хвостовая рекурсия */
+func tailRecur(n int, res int) int {
+	// Условие завершения
+	if n == 0 {
+		return res
+	}
+	// Хвостовой рекурсивный вызов
+	return tailRecur(n-1, res+n)
+}
+
+/* Последовательность Фибоначчи: рекурсия */
+func fib(n int) int {
+	// Условие завершения: f(1) = 0, f(2) = 1
+	if n == 1 || n == 2 {
+		return n - 1
+	}
+	// Рекурсивный вызов f(n) = f(n-1) + f(n-2)
+	res := fib(n-1) + fib(n-2)
+	// Вернуть результат f(n)
+	return res
+}

ru/codes/go/chapter_computational_complexity/recursion_test.go

@@ -0,0 +1,26 @@
+// File: recursion_test.go
+// Created Time: 2023-08-28
+// Author: Reanon (793584285@qq.com)
+
+package chapter_computational_complexity
+
+import (
+	"fmt"
+	"testing"
+)
+
+/* Driver Code */
+func TestRecursion(t *testing.T) {
+	n := 5
+	res := recur(n)
+	fmt.Println("\nРезультат суммирования в рекурсивной функции res = ", res)
+
+	res = forLoopRecur(n)
+	fmt.Println("\nРезультат суммирования при имитации рекурсии итерацией res = ", res)
+
+	res = tailRecur(n, 0)
+	fmt.Println("\nРезультат суммирования в хвостовой рекурсии res = ", res)
+
+	res = fib(n)
+	fmt.Println("\nЧлен последовательности Фибоначчи с номером", n, "=", res)
+}

ru/codes/go/chapter_computational_complexity/space_complexity.go

@@ -0,0 +1,106 @@
+// File: space_complexity.go
+// Created Time: 2022-12-15
+// Author: cathay (cathaycchen@gmail.com)
+
+package chapter_computational_complexity
+
+import (
+	"fmt"
+	"strconv"
+
+	. "github.com/krahets/hello-algo/pkg"
+)
+
+/* Структура */
+type node struct {
+	val  int
+	next *node
+}
+
+/* Создать структуру node */
+func newNode(val int) *node {
+	return &node{val: val}
+}
+
+/* Функция */
+func function() int {
+	// Выполнить некоторые операции...
+	return 0
+}
+
+/* Постоянная сложность */
+func spaceConstant(n int) {
+	// Константы, переменные и объекты занимают O(1) памяти
+	const a = 0
+	b := 0
+	nums := make([]int, 10000)
+	node := newNode(0)
+	// Переменные в цикле занимают O(1) памяти
+	var c int
+	for i := 0; i < n; i++ {
+		c = 0
+	}
+	// Функции в цикле занимают O(1) памяти
+	for i := 0; i < n; i++ {
+		function()
+	}
+	b += 0
+	c += 0
+	nums[0] = 0
+	node.val = 0
+}
+
+/* Линейная сложность */
+func spaceLinear(n int) {
+	// Массив длины n занимает O(n) памяти
+	_ = make([]int, n)
+	// Список длины n занимает O(n) памяти
+	var nodes []*node
+	for i := 0; i < n; i++ {
+		nodes = append(nodes, newNode(i))
+	}
+	// Хеш-таблица длины n занимает O(n) памяти
+	m := make(map[int]string, n)
+	for i := 0; i < n; i++ {
+		m[i] = strconv.Itoa(i)
+	}
+}
+
+/* Линейная сложность (рекурсивная реализация) */
+func spaceLinearRecur(n int) {
+	fmt.Println("Рекурсия n =", n)
+	if n == 1 {
+		return
+	}
+	spaceLinearRecur(n - 1)
+}
+
+/* Квадратичная сложность */
+func spaceQuadratic(n int) {
+	// Матрица занимает O(n^2) памяти
+	numMatrix := make([][]int, n)
+	for i := 0; i < n; i++ {
+		numMatrix[i] = make([]int, n)
+	}
+}
+
+/* Квадратичная сложность (рекурсивная реализация) */
+func spaceQuadraticRecur(n int) int {
+	if n <= 0 {
+		return 0
+	}
+	nums := make([]int, n)
+	fmt.Printf("В рекурсии n = %d, длина nums = %d\n", n, len(nums))
+	return spaceQuadraticRecur(n - 1)
+}
+
+/* Экспоненциальная сложность (построение полного двоичного дерева) */
+func buildTree(n int) *TreeNode {
+	if n == 0 {
+		return nil
+	}
+	root := NewTreeNode(0)
+	root.Left = buildTree(n - 1)
+	root.Right = buildTree(n - 1)
+	return root
+}

ru/codes/go/chapter_computational_complexity/space_complexity_test.go

@@ -0,0 +1,26 @@
+// File: space_complexity_test.go
+// Created Time: 2022-12-15
+// Author: cathay (cathaycchen@gmail.com)
+
+package chapter_computational_complexity
+
+import (
+	"testing"
+
+	. "github.com/krahets/hello-algo/pkg"
+)
+
+func TestSpaceComplexity(t *testing.T) {
+	n := 5
+	// Постоянная сложность
+	spaceConstant(n)
+	// Линейная сложность
+	spaceLinear(n)
+	spaceLinearRecur(n)
+	// Квадратичная сложность
+	spaceQuadratic(n)
+	spaceQuadraticRecur(n)
+	// Экспоненциальная сложность
+	root := buildTree(n)
+	PrintTree(root)
+}

ru/codes/go/chapter_computational_complexity/time_complexity.go

@@ -0,0 +1,130 @@
+// File: time_complexity.go
+// Created Time: 2022-12-13
+// Author: msk397 (machangxinq@gmail.com)
+
+package chapter_computational_complexity
+
+/* Постоянная сложность */
+func constant(n int) int {
+	count := 0
+	size := 100000
+	for i := 0; i < size; i++ {
+		count++
+	}
+	return count
+}
+
+/* Линейная сложность */
+func linear(n int) int {
+	count := 0
+	for i := 0; i < n; i++ {
+		count++
+	}
+	return count
+}
+
+/* Линейная сложность (обход массива) */
+func arrayTraversal(nums []int) int {
+	count := 0
+	// Число итераций пропорционально длине массива
+	for range nums {
+		count++
+	}
+	return count
+}
+
+/* Квадратичная сложность */
+func quadratic(n int) int {
+	count := 0
+	// Число итераций квадратично зависит от размера данных n
+	for i := 0; i < n; i++ {
+		for j := 0; j < n; j++ {
+			count++
+		}
+	}
+	return count
+}
+
+/* Квадратичная сложность (пузырьковая сортировка) */
+func bubbleSort(nums []int) int {
+	count := 0 // Счетчик
+	// Внешний цикл: неотсортированный диапазон [0, i]
+	for i := len(nums) - 1; i > 0; i-- {
+		// Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец
+		for j := 0; j < i; j++ {
+			if nums[j] > nums[j+1] {
+				// Поменять местами nums[j] и nums[j + 1]
+				tmp := nums[j]
+				nums[j] = nums[j+1]
+				nums[j+1] = tmp
+				count += 3 // Обмен элементов включает 3 элементарные операции
+			}
+		}
+	}
+	return count
+}
+
+/* Экспоненциальная сложность (итеративная реализация) */
+func exponential(n int) int {
+	count, base := 0, 1
+	// На каждом шаге клетка делится надвое, образуя последовательность 1, 2, 4, 8, ..., 2^(n-1)
+	for i := 0; i < n; i++ {
+		for j := 0; j < base; j++ {
+			count++
+		}
+		base *= 2
+	}
+	// count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1
+	return count
+}
+
+/* Экспоненциальная сложность (рекурсивная реализация) */
+func expRecur(n int) int {
+	if n == 1 {
+		return 1
+	}
+	return expRecur(n-1) + expRecur(n-1) + 1
+}
+
+/* Логарифмическая сложность (итеративная реализация) */
+func logarithmic(n int) int {
+	count := 0
+	for n > 1 {
+		n = n / 2
+		count++
+	}
+	return count
+}
+
+/* Логарифмическая сложность (рекурсивная реализация) */
+func logRecur(n int) int {
+	if n <= 1 {
+		return 0
+	}
+	return logRecur(n/2) + 1
+}
+
+/* Линейно-логарифмическая сложность */
+func linearLogRecur(n int) int {
+	if n <= 1 {
+		return 1
+	}
+	count := linearLogRecur(n/2) + linearLogRecur(n/2)
+	for i := 0; i < n; i++ {
+		count++
+	}
+	return count
+}
+
+/* Факториальная сложность (рекурсивная реализация) */
+func factorialRecur(n int) int {
+	if n == 0 {
+		return 1
+	}
+	count := 0
+	// Из одного получается n
+	for i := 0; i < n; i++ {
+		count += factorialRecur(n - 1)
+	}
+	return count
+}

ru/codes/go/chapter_computational_complexity/time_complexity_test.go

@@ -0,0 +1,48 @@
+// File: time_complexity_test.go
+// Created Time: 2022-12-13
+// Author: msk397 (machangxinq@gmail.com)
+
+package chapter_computational_complexity
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestTimeComplexity(t *testing.T) {
+	n := 8
+	fmt.Println("Размер входных данных n =", n)
+
+	count := constant(n)
+	fmt.Println("Число операций константной сложности =", count)
+
+	count = linear(n)
+	fmt.Println("Число операций линейной сложности =", count)
+	count = arrayTraversal(make([]int, n))
+	fmt.Println("Число операций линейной сложности (обход массива) =", count)
+
+	count = quadratic(n)
+	fmt.Println("Число операций квадратичной сложности =", count)
+	nums := make([]int, n)
+	for i := 0; i < n; i++ {
+		nums[i] = n - i
+	}
+	count = bubbleSort(nums)
+	fmt.Println("Число операций квадратичной сложности (пузырьковая сортировка) =", count)
+
+	count = exponential(n)
+	fmt.Println("Число операций экспоненциальной сложности (итеративная реализация) =", count)
+	count = expRecur(n)
+	fmt.Println("Число операций экспоненциальной сложности (рекурсивная реализация) =", count)
+
+	count = logarithmic(n)
+	fmt.Println("Число операций логарифмической сложности (итеративная реализация) =", count)
+	count = logRecur(n)
+	fmt.Println("Число операций логарифмической сложности (рекурсивная реализация) =", count)
+
+	count = linearLogRecur(n)
+	fmt.Println("Число операций линейно-логарифмической сложности (рекурсивная реализация) =", count)
+
+	count = factorialRecur(n)
+	fmt.Println("Число операций факториальной сложности (рекурсивная реализация) =", count)
+}

ru/codes/go/chapter_computational_complexity/worst_best_time_complexity.go

@@ -0,0 +1,35 @@
+// File: worst_best_time_complexity.go
+// Created Time: 2022-12-13
+// Author: msk397 (machangxinq@gmail.com), cathay (cathaycchen@gmail.com)
+
+package chapter_computational_complexity
+
+import (
+	"math/rand"
+)
+
+/* Создать массив с элементами { 1, 2, ..., n } в случайном порядке */
+func randomNumbers(n int) []int {
+	nums := make([]int, n)
+	// Создать массив nums = { 1, 2, 3, ..., n }
+	for i := 0; i < n; i++ {
+		nums[i] = i + 1
+	}
+	// Случайно перемешать элементы массива
+	rand.Shuffle(len(nums), func(i, j int) {
+		nums[i], nums[j] = nums[j], nums[i]
+	})
+	return nums
+}
+
+/* Найти индекс числа 1 в массиве nums */
+func findOne(nums []int) int {
+	for i := 0; i < len(nums); i++ {
+		// Когда элемент 1 находится в начале массива, достигается лучшая временная сложность O(1)
+		// Когда элемент 1 находится в конце массива, достигается худшая временная сложность O(n)
+		if nums[i] == 1 {
+			return i
+		}
+	}
+	return -1
+}

ru/codes/go/chapter_computational_complexity/worst_best_time_complexity_test.go

@@ -0,0 +1,20 @@
+// File: worst_best_time_complexity_test.go
+// Created Time: 2022-12-13
+// Author: msk397 (machangxinq@gmail.com), cathay (cathaycchen@gmail.com)
+
+package chapter_computational_complexity
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestWorstBestTimeComplexity(t *testing.T) {
+	for i := 0; i < 10; i++ {
+		n := 100
+		nums := randomNumbers(n)
+		index := findOne(nums)
+		fmt.Println("\nМассив [1, 2, ..., n] после перемешивания =", nums)
+		fmt.Println("Индекс числа 1 =", index)
+	}
+}

ru/codes/go/chapter_divide_and_conquer/binary_search_recur.go

@@ -0,0 +1,34 @@
+// File: binary_search_recur.go
+// Created Time: 2023-07-19
+// Author: hongyun-robot (1836017030@qq.com)
+
+package chapter_divide_and_conquer
+
+/* Бинарный поиск: задача f(i, j) */
+func dfs(nums []int, target, i, j int) int {
+	// Если интервал пуст, это означает отсутствие целевого элемента, вернуть -1
+	if i > j {
+		return -1
+	}
+	// Вычислить средний индекс
+	m := i + ((j - i) >> 1)
+	// Сравнить середину и целевой элемент
+	if nums[m] < target {
+		// Если меньше, рекурсивно обрабатывать правую половину массива
+		// Рекурсивная подзадача f(m+1, j)
+		return dfs(nums, target, m+1, j)
+	} else if nums[m] > target {
+		// Если больше, рекурсивно обработать левую половину массива
+		// Рекурсивная подзадача f(i, m-1)
+		return dfs(nums, target, i, m-1)
+	} else {
+		// Целевой элемент найден, вернуть его индекс
+		return m
+	}
+}
+
+/* Бинарный поиск */
+func binarySearch(nums []int, target int) int {
+	n := len(nums)
+	return dfs(nums, target, 0, n-1)
+}

ru/codes/go/chapter_divide_and_conquer/binary_search_recur_test.go

@@ -0,0 +1,20 @@
+// File: binary_search_recur_test.go
+// Created Time: 2023-07-19
+// Author: hongyun-robot (1836017030@qq.com)
+
+package chapter_divide_and_conquer
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestBinarySearch(t *testing.T) {
+	nums := []int{1, 3, 6, 8, 12, 15, 23, 26, 31, 35}
+	target := 6
+	noTarget := 99
+	targetIndex := binarySearch(nums, target)
+	fmt.Println("Индекс целевого элемента 6 = ", targetIndex)
+	noTargetIndex := binarySearch(nums, noTarget)
+	fmt.Println("Индекс отсутствующего целевого элемента =", noTargetIndex)
+}

ru/codes/go/chapter_divide_and_conquer/build_tree.go

@@ -0,0 +1,37 @@
+// File: build_tree.go
+// Created Time: 2023-07-20
+// Author: hongyun-robot (1836017030@qq.com)
+
+package chapter_divide_and_conquer
+
+import . "github.com/krahets/hello-algo/pkg"
+
+/* Построить двоичное дерево: разделяй и властвуй */
+func dfsBuildTree(preorder []int, inorderMap map[int]int, i, l, r int) *TreeNode {
+	// Завершить при пустом диапазоне поддерева
+	if r-l < 0 {
+		return nil
+	}
+	// Инициализировать корневой узел
+	root := NewTreeNode(preorder[i])
+	// Найти m, чтобы разделить левое и правое поддеревья
+	m := inorderMap[preorder[i]]
+	// Подзадача: построить левое поддерево
+	root.Left = dfsBuildTree(preorder, inorderMap, i+1, l, m-1)
+	// Подзадача: построить правое поддерево
+	root.Right = dfsBuildTree(preorder, inorderMap, i+1+m-l, m+1, r)
+	// Вернуть корневой узел
+	return root
+}
+
+/* Построить двоичное дерево */
+func buildTree(preorder, inorder []int) *TreeNode {
+	// Инициализировать хеш-таблицу для хранения соответствия элементов inorder их индексам
+	inorderMap := make(map[int]int, len(inorder))
+	for i := 0; i < len(inorder); i++ {
+		inorderMap[inorder[i]] = i
+	}
+
+	root := dfsBuildTree(preorder, inorderMap, 0, 0, len(inorder)-1)
+	return root
+}

ru/codes/go/chapter_divide_and_conquer/build_tree_test.go

@@ -0,0 +1,25 @@
+// File: build_tree_test.go
+// Created Time: 2023-07-20
+// Author: hongyun-robot (1836017030@qq.com)
+
+package chapter_divide_and_conquer
+
+import (
+	"fmt"
+	"testing"
+
+	. "github.com/krahets/hello-algo/pkg"
+)
+
+func TestBuildTree(t *testing.T) {
+	preorder := []int{3, 9, 2, 1, 7}
+	inorder := []int{9, 3, 1, 2, 7}
+	fmt.Print("Предварительный обход = ")
+	PrintSlice(preorder)
+	fmt.Print("Симметричный обход = ")
+	PrintSlice(inorder)
+
+	root := buildTree(preorder, inorder)
+	fmt.Println("Построенное двоичное дерево:")
+	PrintTree(root)
+}

ru/codes/go/chapter_divide_and_conquer/hanota.go

@@ -0,0 +1,39 @@
+// File: hanota.go
+// Created Time: 2023-07-21
+// Author: hongyun-robot (1836017030@qq.com)
+
+package chapter_divide_and_conquer
+
+import "container/list"
+
+/* Переместить один диск */
+func move(src, tar *list.List) {
+	// Снять диск с вершины src
+	pan := src.Back()
+	// Положить диск на вершину tar
+	tar.PushBack(pan.Value)
+	// Убрать верхний диск из src
+	src.Remove(pan)
+}
+
+/* Решить задачу Ханойской башни f(i) */
+func dfsHanota(i int, src, buf, tar *list.List) {
+	// Если в src остался только один диск, сразу переместить его в tar
+	if i == 1 {
+		move(src, tar)
+		return
+	}
+	// Подзадача f(i-1): переместить верхние i-1 дисков из src в buf с помощью tar
+	dfsHanota(i-1, src, tar, buf)
+	// Подзадача f(1): переместить оставшийся один диск из src в tar
+	move(src, tar)
+	// Подзадача f(i-1): переместить верхние i-1 дисков из buf в tar с помощью src
+	dfsHanota(i-1, buf, src, tar)
+}
+
+/* Решить задачу Ханойской башни */
+func solveHanota(A, B, C *list.List) {
+	n := A.Len()
+	// Переместить верхние n дисков из A в C с помощью B
+	dfsHanota(n, A, B, C)
+}

ru/codes/go/chapter_divide_and_conquer/hanota_test.go

@@ -0,0 +1,40 @@
+// File: hanota_test.go
+// Created Time: 2023-07-21
+// Author: hongyun-robot (1836017030@qq.com)
+
+package chapter_divide_and_conquer
+
+import (
+	"container/list"
+	"fmt"
+	"testing"
+
+	. "github.com/krahets/hello-algo/pkg"
+)
+
+func TestHanota(t *testing.T) {
+	// Хвост списка соответствует вершине столбца
+	A := list.New()
+	for i := 5; i > 0; i-- {
+		A.PushBack(i)
+	}
+	B := list.New()
+	C := list.New()
+	fmt.Println("Исходное состояние:")
+	fmt.Print("A = ")
+	PrintList(A)
+	fmt.Print("B = ")
+	PrintList(B)
+	fmt.Print("C = ")
+	PrintList(C)
+
+	solveHanota(A, B, C)
+
+	fmt.Println("После завершения перемещения дисков:")
+	fmt.Print("A = ")
+	PrintList(A)
+	fmt.Print("B = ")
+	PrintList(B)
+	fmt.Print("C = ")
+	PrintList(C)
+}

ru/codes/go/chapter_dynamic_programming/climbing_stairs_backtrack.go

@@ -0,0 +1,36 @@
+// File: climbing_stairs_backtrack.go
+// Created Time: 2023-07-18
+// Author: Reanon (793584285@qq.com)
+
+package chapter_dynamic_programming
+
+/* Бэктрекинг */
+func backtrack(choices []int, state, n int, res []int) {
+	// Когда подъем достигает n-й ступени, число вариантов увеличивается на 1
+	if state == n {
+		res[0] = res[0] + 1
+	}
+	// Перебор всех вариантов выбора
+	for _, choice := range choices {
+		// Отсечение: нельзя выходить за n-ю ступень
+		if state+choice > n {
+			continue
+		}
+		// Попытка: сделать выбор и обновить состояние
+		backtrack(choices, state+choice, n, res)
+		// Откат
+	}
+}
+
+/* Подъем по лестнице: бэктрекинг */
+func climbingStairsBacktrack(n int) int {
+	// Можно подняться на 1 или 2 ступени
+	choices := []int{1, 2}
+	// Начать подъем с 0-й ступени
+	state := 0
+	res := make([]int, 1)
+	// Использовать res[0] для хранения числа решений
+	res[0] = 0
+	backtrack(choices, state, n, res)
+	return res[0]
+}

ru/codes/go/chapter_dynamic_programming/climbing_stairs_constraint_dp.go

@@ -0,0 +1,25 @@
+// File: climbing_stairs_constraint_dp.go
+// Created Time: 2023-07-18
+// Author: Reanon (793584285@qq.com)
+
+package chapter_dynamic_programming
+
+/* Подъем по лестнице с ограничениями: динамическое программирование */
+func climbingStairsConstraintDP(n int) int {
+	if n == 1 || n == 2 {
+		return 1
+	}
+	// Инициализация таблицы dp для хранения решений подзадач
+	dp := make([][3]int, n+1)
+	// Начальное состояние: заранее задать решения наименьших подзадач
+	dp[1][1] = 1
+	dp[1][2] = 0
+	dp[2][1] = 0
+	dp[2][2] = 1
+	// Переход состояний: постепенное решение больших подзадач через меньшие
+	for i := 3; i <= n; i++ {
+		dp[i][1] = dp[i-1][2]
+		dp[i][2] = dp[i-2][1] + dp[i-2][2]
+	}
+	return dp[n][1] + dp[n][2]
+}

ru/codes/go/chapter_dynamic_programming/climbing_stairs_dfs.go

@@ -0,0 +1,21 @@
+// File: climbing_stairs_dfs.go
+// Created Time: 2023-07-18
+// Author: Reanon (793584285@qq.com)
+
+package chapter_dynamic_programming
+
+/* Поиск */
+func dfs(i int) int {
+	// dp[1] и dp[2] уже известны, вернуть их
+	if i == 1 || i == 2 {
+		return i
+	}
+	// dp[i] = dp[i-1] + dp[i-2]
+	count := dfs(i-1) + dfs(i-2)
+	return count
+}
+
+/* Подъем по лестнице: поиск */
+func climbingStairsDFS(n int) int {
+	return dfs(n)
+}

ru/codes/go/chapter_dynamic_programming/climbing_stairs_dfs_mem.go

@@ -0,0 +1,32 @@
+// File: climbing_stairs_dfs_mem.go
+// Created Time: 2023-07-18
+// Author: Reanon (793584285@qq.com)
+
+package chapter_dynamic_programming
+
+/* Поиск с мемоизацией */
+func dfsMem(i int, mem []int) int {
+	// dp[1] и dp[2] уже известны, вернуть их
+	if i == 1 || i == 2 {
+		return i
+	}
+	// Если запись dp[i] существует, сразу вернуть ее
+	if mem[i] != -1 {
+		return mem[i]
+	}
+	// dp[i] = dp[i-1] + dp[i-2]
+	count := dfsMem(i-1, mem) + dfsMem(i-2, mem)
+	// Сохранить dp[i]
+	mem[i] = count
+	return count
+}
+
+/* Подъем по лестнице: поиск с мемоизацией */
+func climbingStairsDFSMem(n int) int {
+	// mem[i] хранит число способов подняться на i-ю ступень, -1 означает отсутствие записи
+	mem := make([]int, n+1)
+	for i := range mem {
+		mem[i] = -1
+	}
+	return dfsMem(n, mem)
+}

ru/codes/go/chapter_dynamic_programming/climbing_stairs_dp.go

@@ -0,0 +1,35 @@
+// File: climbing_stairs_dp.go
+// Created Time: 2023-07-18
+// Author: Reanon (793584285@qq.com)
+
+package chapter_dynamic_programming
+
+/* Подъем по лестнице: динамическое программирование */
+func climbingStairsDP(n int) int {
+	if n == 1 || n == 2 {
+		return n
+	}
+	// Инициализация таблицы dp для хранения решений подзадач
+	dp := make([]int, n+1)
+	// Начальное состояние: заранее задать решения наименьших подзадач
+	dp[1] = 1
+	dp[2] = 2
+	// Переход состояний: постепенное решение больших подзадач через меньшие
+	for i := 3; i <= n; i++ {
+		dp[i] = dp[i-1] + dp[i-2]
+	}
+	return dp[n]
+}
+
+/* Подъем по лестнице: динамическое программирование с оптимизацией памяти */
+func climbingStairsDPComp(n int) int {
+	if n == 1 || n == 2 {
+		return n
+	}
+	a, b := 1, 2
+	// Переход состояний: постепенное решение больших подзадач через меньшие
+	for i := 3; i <= n; i++ {
+		a, b = b, a+b
+	}
+	return b
+}

ru/codes/go/chapter_dynamic_programming/climbing_stairs_test.go

@@ -0,0 +1,57 @@
+// File: climbing_stairs_test.go
+// Created Time: 2023-07-18
+// Author: Reanon (793584285@qq.com)
+
+package chapter_dynamic_programming
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestClimbingStairsBacktrack(t *testing.T) {
+	n := 9
+	res := climbingStairsBacktrack(n)
+	fmt.Printf("Количество способов подняться по лестнице из %d ступеней: %d\n", n, res)
+}
+
+func TestClimbingStairsDFS(t *testing.T) {
+	n := 9
+	res := climbingStairsDFS(n)
+	fmt.Printf("Количество способов подняться по лестнице из %d ступеней: %d\n", n, res)
+}
+
+func TestClimbingStairsDFSMem(t *testing.T) {
+	n := 9
+	res := climbingStairsDFSMem(n)
+	fmt.Printf("Количество способов подняться по лестнице из %d ступеней: %d\n", n, res)
+}
+
+func TestClimbingStairsDP(t *testing.T) {
+	n := 9
+	res := climbingStairsDP(n)
+	fmt.Printf("Количество способов подняться по лестнице из %d ступеней: %d\n", n, res)
+}
+
+func TestClimbingStairsDPComp(t *testing.T) {
+	n := 9
+	res := climbingStairsDPComp(n)
+	fmt.Printf("Количество способов подняться по лестнице из %d ступеней: %d\n", n, res)
+}
+
+func TestClimbingStairsConstraintDP(t *testing.T) {
+	n := 9
+	res := climbingStairsConstraintDP(n)
+	fmt.Printf("Количество способов подняться по лестнице из %d ступеней: %d\n", n, res)
+}
+
+func TestMinCostClimbingStairsDPComp(t *testing.T) {
+	cost := []int{0, 1, 10, 1, 1, 1, 10, 1, 1, 10, 1}
+	fmt.Printf("Список стоимостей ступеней = %v\n", cost)
+
+	res := minCostClimbingStairsDP(cost)
+	fmt.Printf("Минимальная стоимость подъема по лестнице = %d\n", res)
+
+	res = minCostClimbingStairsDPComp(cost)
+	fmt.Printf("Минимальная стоимость подъема по лестнице = %d\n", res)
+}

ru/codes/go/chapter_dynamic_programming/coin_change.go

@@ -0,0 +1,66 @@
+// File: coin_change.go
+// Created Time: 2023-07-23
+// Author: Reanon (793584285@qq.com)
+
+package chapter_dynamic_programming
+
+import "math"
+
+/* Размен монет: динамическое программирование */
+func coinChangeDP(coins []int, amt int) int {
+	n := len(coins)
+	max := amt + 1
+	// Инициализация таблицы dp
+	dp := make([][]int, n+1)
+	for i := 0; i <= n; i++ {
+		dp[i] = make([]int, amt+1)
+	}
+	// Переход состояний: первая строка и первый столбец
+	for a := 1; a <= amt; a++ {
+		dp[0][a] = max
+	}
+	// Переход состояний: остальные строки и столбцы
+	for i := 1; i <= n; i++ {
+		for a := 1; a <= amt; a++ {
+			if coins[i-1] > a {
+				// Если целевая сумма превышена, монету i не выбирать
+				dp[i][a] = dp[i-1][a]
+			} else {
+				// Меньшее из двух решений: не брать или взять монету i
+				dp[i][a] = int(math.Min(float64(dp[i-1][a]), float64(dp[i][a-coins[i-1]]+1)))
+			}
+		}
+	}
+	if dp[n][amt] != max {
+		return dp[n][amt]
+	}
+	return -1
+}
+
+/* Размен монет: динамическое программирование */
+func coinChangeDPComp(coins []int, amt int) int {
+	n := len(coins)
+	max := amt + 1
+	// Инициализация таблицы dp
+	dp := make([]int, amt+1)
+	for i := 1; i <= amt; i++ {
+		dp[i] = max
+	}
+	// Переход состояний
+	for i := 1; i <= n; i++ {
+		// Прямой обход
+		for a := 1; a <= amt; a++ {
+			if coins[i-1] > a {
+				// Если целевая сумма превышена, монету i не выбирать
+				dp[a] = dp[a]
+			} else {
+				// Меньшее из двух решений: не брать или взять монету i
+				dp[a] = int(math.Min(float64(dp[a]), float64(dp[a-coins[i-1]]+1)))
+			}
+		}
+	}
+	if dp[amt] != max {
+		return dp[amt]
+	}
+	return -1
+}

ru/codes/go/chapter_dynamic_programming/coin_change_ii.go

@@ -0,0 +1,54 @@
+// File: coin_change_ii.go
+// Created Time: 2023-07-23
+// Author: Reanon (793584285@qq.com)
+
+package chapter_dynamic_programming
+
+/* Размен монет II: динамическое программирование */
+func coinChangeIIDP(coins []int, amt int) int {
+	n := len(coins)
+	// Инициализация таблицы dp
+	dp := make([][]int, n+1)
+	for i := 0; i <= n; i++ {
+		dp[i] = make([]int, amt+1)
+	}
+	// Инициализация первого столбца
+	for i := 0; i <= n; i++ {
+		dp[i][0] = 1
+	}
+	// Переход состояний: остальные строки и столбцы
+	for i := 1; i <= n; i++ {
+		for a := 1; a <= amt; a++ {
+			if coins[i-1] > a {
+				// Если целевая сумма превышена, монету i не выбирать
+				dp[i][a] = dp[i-1][a]
+			} else {
+				// Сумма двух решений: не брать или взять монету i
+				dp[i][a] = dp[i-1][a] + dp[i][a-coins[i-1]]
+			}
+		}
+	}
+	return dp[n][amt]
+}
+
+/* Размен монет II: динамическое программирование с оптимизацией памяти */
+func coinChangeIIDPComp(coins []int, amt int) int {
+	n := len(coins)
+	// Инициализация таблицы dp
+	dp := make([]int, amt+1)
+	dp[0] = 1
+	// Переход состояний
+	for i := 1; i <= n; i++ {
+		// Прямой обход
+		for a := 1; a <= amt; a++ {
+			if coins[i-1] > a {
+				// Если целевая сумма превышена, монету i не выбирать
+				dp[a] = dp[a]
+			} else {
+				// Сумма двух решений: не брать или взять монету i
+				dp[a] = dp[a] + dp[a-coins[i-1]]
+			}
+		}
+	}
+	return dp[amt]
+}

ru/codes/go/chapter_dynamic_programming/coin_change_test.go

@@ -0,0 +1,23 @@
+// File: coin_change_test.go
+// Created Time: 2023-07-23
+// Author: Reanon (793584285@qq.com)
+
+package chapter_dynamic_programming
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestCoinChange(t *testing.T) {
+	coins := []int{1, 2, 5}
+	amt := 4
+
+	// Динамическое программирование
+	res := coinChangeDP(coins, amt)
+	fmt.Printf("Минимальное число монет для набора целевой суммы = %d\n", res)
+
+	// Динамическое программирование с оптимизацией памяти
+	res = coinChangeDPComp(coins, amt)
+	fmt.Printf("Минимальное число монет для набора целевой суммы = %d\n", res)
+}

ru/codes/go/chapter_dynamic_programming/edit_distance.go

@@ -0,0 +1,129 @@
+// File: edit_distance.go
+// Created Time: 2023-07-23
+// Author: Reanon (793584285@qq.com)
+
+package chapter_dynamic_programming
+
+/* Редакционное расстояние: полный перебор */
+func editDistanceDFS(s string, t string, i int, j int) int {
+	// Если s и t пусты, вернуть 0
+	if i == 0 && j == 0 {
+		return 0
+	}
+	// Если s пусто, вернуть длину t
+	if i == 0 {
+		return j
+	}
+	// Если t пусто, вернуть длину s
+	if j == 0 {
+		return i
+	}
+	// Если два символа равны, сразу пропустить их
+	if s[i-1] == t[j-1] {
+		return editDistanceDFS(s, t, i-1, j-1)
+	}
+	// Минимальное число шагов редактирования = минимальное число шагов для вставки, удаления и замены + 1
+	insert := editDistanceDFS(s, t, i, j-1)
+	deleted := editDistanceDFS(s, t, i-1, j)
+	replace := editDistanceDFS(s, t, i-1, j-1)
+	// Вернуть минимальное число шагов редактирования
+	return MinInt(MinInt(insert, deleted), replace) + 1
+}
+
+/* Редакционное расстояние: поиск с мемоизацией */
+func editDistanceDFSMem(s string, t string, mem [][]int, i int, j int) int {
+	// Если s и t пусты, вернуть 0
+	if i == 0 && j == 0 {
+		return 0
+	}
+	// Если s пусто, вернуть длину t
+	if i == 0 {
+		return j
+	}
+	// Если t пусто, вернуть длину s
+	if j == 0 {
+		return i
+	}
+	// Если запись уже есть, сразу вернуть ее
+	if mem[i][j] != -1 {
+		return mem[i][j]
+	}
+	// Если два символа равны, сразу пропустить их
+	if s[i-1] == t[j-1] {
+		return editDistanceDFSMem(s, t, mem, i-1, j-1)
+	}
+	// Минимальное число шагов редактирования = минимальное число шагов для вставки, удаления и замены + 1
+	insert := editDistanceDFSMem(s, t, mem, i, j-1)
+	deleted := editDistanceDFSMem(s, t, mem, i-1, j)
+	replace := editDistanceDFSMem(s, t, mem, i-1, j-1)
+	// Сохранить и вернуть минимальное число шагов редактирования
+	mem[i][j] = MinInt(MinInt(insert, deleted), replace) + 1
+	return mem[i][j]
+}
+
+/* Редакционное расстояние: динамическое программирование */
+func editDistanceDP(s string, t string) int {
+	n := len(s)
+	m := len(t)
+	dp := make([][]int, n+1)
+	for i := 0; i <= n; i++ {
+		dp[i] = make([]int, m+1)
+	}
+	// Переход состояний: первая строка и первый столбец
+	for i := 1; i <= n; i++ {
+		dp[i][0] = i
+	}
+	for j := 1; j <= m; j++ {
+		dp[0][j] = j
+	}
+	// Переход состояний: остальные строки и столбцы
+	for i := 1; i <= n; i++ {
+		for j := 1; j <= m; j++ {
+			if s[i-1] == t[j-1] {
+				// Если два символа равны, сразу пропустить их
+				dp[i][j] = dp[i-1][j-1]
+			} else {
+				// Минимальное число шагов редактирования = минимальное число шагов для вставки, удаления и замены + 1
+				dp[i][j] = MinInt(MinInt(dp[i][j-1], dp[i-1][j]), dp[i-1][j-1]) + 1
+			}
+		}
+	}
+	return dp[n][m]
+}
+
+/* Редакционное расстояние: динамическое программирование с оптимизацией памяти */
+func editDistanceDPComp(s string, t string) int {
+	n := len(s)
+	m := len(t)
+	dp := make([]int, m+1)
+	// Переход состояний: первая строка
+	for j := 1; j <= m; j++ {
+		dp[j] = j
+	}
+	// Переход состояний: остальные строки
+	for i := 1; i <= n; i++ {
+		// Переход состояний: первый столбец
+		leftUp := dp[0] // Временно сохранить dp[i-1, j-1]
+		dp[0] = i
+		// Переход состояний: остальные столбцы
+		for j := 1; j <= m; j++ {
+			temp := dp[j]
+			if s[i-1] == t[j-1] {
+				// Если два символа равны, сразу пропустить их
+				dp[j] = leftUp
+			} else {
+				// Минимальное число шагов редактирования = минимальное число шагов для вставки, удаления и замены + 1
+				dp[j] = MinInt(MinInt(dp[j-1], dp[j]), leftUp) + 1
+			}
+			leftUp = temp // Обновить до значения dp[i-1, j-1] для следующей итерации
+		}
+	}
+	return dp[m]
+}
+
+func MinInt(a, b int) int {
+	if a < b {
+		return a
+	}
+	return b
+}

ru/codes/go/chapter_dynamic_programming/edit_distance_test.go

@@ -0,0 +1,40 @@
+// File: edit_distance_test.go
+// Created Time: 2023-07-23
+// Author: Reanon (793584285@qq.com)
+
+package chapter_dynamic_programming
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestEditDistanceDFS(test *testing.T) {
+	s := "bag"
+	t := "pack"
+	n := len(s)
+	m := len(t)
+
+	// Полный перебор
+	res := editDistanceDFS(s, t, n, m)
+	fmt.Printf("Чтобы преобразовать %s в %s, нужно минимум %d шагов\n", s, t, res)
+
+	// Поиск с мемоизацией
+	mem := make([][]int, n+1)
+	for i := 0; i <= n; i++ {
+		mem[i] = make([]int, m+1)
+		for j := 0; j <= m; j++ {
+			mem[i][j] = -1
+		}
+	}
+	res = editDistanceDFSMem(s, t, mem, n, m)
+	fmt.Printf("Чтобы преобразовать %s в %s, нужно минимум %d шагов\n", s, t, res)
+
+	// Динамическое программирование
+	res = editDistanceDP(s, t)
+	fmt.Printf("Чтобы преобразовать %s в %s, нужно минимум %d шагов\n", s, t, res)
+
+	// Динамическое программирование с оптимизацией памяти
+	res = editDistanceDPComp(s, t)
+	fmt.Printf("Чтобы преобразовать %s в %s, нужно минимум %d шагов\n", s, t, res)
+}

ru/codes/go/chapter_dynamic_programming/knapsack.go

@@ -0,0 +1,87 @@
+// File: knapsack.go
+// Created Time: 2023-07-23
+// Author: Reanon (793584285@qq.com)
+
+package chapter_dynamic_programming
+
+import "math"
+
+/* Рюкзак 0-1: полный перебор */
+func knapsackDFS(wgt, val []int, i, c int) int {
+	// Если все предметы уже рассмотрены или в рюкзаке не осталось места, вернуть стоимость 0
+	if i == 0 || c == 0 {
+		return 0
+	}
+	// Если вместимость рюкзака превышена, можно только не класть предмет в рюкзак
+	if wgt[i-1] > c {
+		return knapsackDFS(wgt, val, i-1, c)
+	}
+	// Вычислить максимальную стоимость для случаев, когда предмет i не кладут и кладут
+	no := knapsackDFS(wgt, val, i-1, c)
+	yes := knapsackDFS(wgt, val, i-1, c-wgt[i-1]) + val[i-1]
+	// Вернуть вариант с большей стоимостью из двух возможных
+	return int(math.Max(float64(no), float64(yes)))
+}
+
+/* Рюкзак 0-1: поиск с мемоизацией */
+func knapsackDFSMem(wgt, val []int, mem [][]int, i, c int) int {
+	// Если все предметы уже рассмотрены или в рюкзаке не осталось места, вернуть стоимость 0
+	if i == 0 || c == 0 {
+		return 0
+	}
+	// Если запись уже есть, вернуть сразу
+	if mem[i][c] != -1 {
+		return mem[i][c]
+	}
+	// Если вместимость рюкзака превышена, можно только не класть предмет в рюкзак
+	if wgt[i-1] > c {
+		return knapsackDFSMem(wgt, val, mem, i-1, c)
+	}
+	// Вычислить максимальную стоимость для случаев, когда предмет i не кладут и кладут
+	no := knapsackDFSMem(wgt, val, mem, i-1, c)
+	yes := knapsackDFSMem(wgt, val, mem, i-1, c-wgt[i-1]) + val[i-1]
+	// Вернуть вариант с большей стоимостью из двух возможных
+	mem[i][c] = int(math.Max(float64(no), float64(yes)))
+	return mem[i][c]
+}
+
+/* Рюкзак 0-1: динамическое программирование */
+func knapsackDP(wgt, val []int, cap int) int {
+	n := len(wgt)
+	// Инициализация таблицы dp
+	dp := make([][]int, n+1)
+	for i := 0; i <= n; i++ {
+		dp[i] = make([]int, cap+1)
+	}
+	// Переход состояний
+	for i := 1; i <= n; i++ {
+		for c := 1; c <= cap; c++ {
+			if wgt[i-1] > c {
+				// Если вместимость рюкзака превышена, предмет i не выбирать
+				dp[i][c] = dp[i-1][c]
+			} else {
+				// Большее из двух решений: не брать или взять предмет i
+				dp[i][c] = int(math.Max(float64(dp[i-1][c]), float64(dp[i-1][c-wgt[i-1]]+val[i-1])))
+			}
+		}
+	}
+	return dp[n][cap]
+}
+
+/* Рюкзак 0-1: динамическое программирование с оптимизацией памяти */
+func knapsackDPComp(wgt, val []int, cap int) int {
+	n := len(wgt)
+	// Инициализация таблицы dp
+	dp := make([]int, cap+1)
+	// Переход состояний
+	for i := 1; i <= n; i++ {
+		// Обход в обратном порядке
+		for c := cap; c >= 1; c-- {
+			if wgt[i-1] <= c {
+				// Большее из двух решений: не брать или взять предмет i
+				dp[c] = int(math.Max(float64(dp[c]), float64(dp[c-wgt[i-1]]+val[i-1])))
+			}
+		}
+	}
+	return dp[cap]
+}

ru/codes/go/chapter_dynamic_programming/knapsack_test.go

@@ -0,0 +1,54 @@
+// File: knapsack_test.go
+// Created Time: 2023-07-23
+// Author: Reanon (793584285@qq.com)
+
+package chapter_dynamic_programming
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestKnapsack(t *testing.T) {
+	wgt := []int{10, 20, 30, 40, 50}
+	val := []int{50, 120, 150, 210, 240}
+	c := 50
+	n := len(wgt)
+
+	// Полный перебор
+	res := knapsackDFS(wgt, val, n, c)
+	fmt.Printf("Максимальная стоимость предметов без превышения вместимости рюкзака = %d\n", res)
+
+	// Поиск с мемоизацией
+	mem := make([][]int, n+1)
+	for i := 0; i <= n; i++ {
+		mem[i] = make([]int, c+1)
+		for j := 0; j <= c; j++ {
+			mem[i][j] = -1
+		}
+	}
+	res = knapsackDFSMem(wgt, val, mem, n, c)
+	fmt.Printf("Максимальная стоимость предметов без превышения вместимости рюкзака = %d\n", res)
+
+	// Динамическое программирование
+	res = knapsackDP(wgt, val, c)
+	fmt.Printf("Максимальная стоимость предметов без превышения вместимости рюкзака = %d\n", res)
+
+	// Динамическое программирование с оптимизацией памяти
+	res = knapsackDPComp(wgt, val, c)
+	fmt.Printf("Максимальная стоимость предметов без превышения вместимости рюкзака = %d\n", res)
+}
+
+func TestUnboundedKnapsack(t *testing.T) {
+	wgt := []int{1, 2, 3}
+	val := []int{5, 11, 15}
+	c := 4
+
+	// Динамическое программирование
+	res := unboundedKnapsackDP(wgt, val, c)
+	fmt.Printf("Максимальная стоимость предметов без превышения вместимости рюкзака = %d\n", res)
+
+	// Динамическое программирование с оптимизацией памяти
+	res = unboundedKnapsackDPComp(wgt, val, c)
+	fmt.Printf("Максимальная стоимость предметов без превышения вместимости рюкзака = %d\n", res)
+}

ru/codes/go/chapter_dynamic_programming/min_cost_climbing_stairs_dp.go

@@ -0,0 +1,52 @@
+// File: min_cost_climbing_stairs_dp.go
+// Created Time: 2023-07-23
+// Author: Reanon (793584285@qq.com)
+
+package chapter_dynamic_programming
+
+/* Минимальная стоимость подъема по лестнице: динамическое программирование */
+func minCostClimbingStairsDP(cost []int) int {
+	n := len(cost) - 1
+	if n == 1 || n == 2 {
+		return cost[n]
+	}
+	min := func(a, b int) int {
+		if a < b {
+			return a
+		}
+		return b
+	}
+	// Инициализация таблицы dp для хранения решений подзадач
+	dp := make([]int, n+1)
+	// Начальное состояние: заранее задать решения наименьших подзадач
+	dp[1] = cost[1]
+	dp[2] = cost[2]
+	// Переход состояний: постепенное решение больших подзадач через меньшие
+	for i := 3; i <= n; i++ {
+		dp[i] = min(dp[i-1], dp[i-2]) + cost[i]
+	}
+	return dp[n]
+}
+
+/* Минимальная стоимость подъема по лестнице: динамическое программирование с оптимизацией памяти */
+func minCostClimbingStairsDPComp(cost []int) int {
+	n := len(cost) - 1
+	if n == 1 || n == 2 {
+		return cost[n]
+	}
+	min := func(a, b int) int {
+		if a < b {
+			return a
+		}
+		return b
+	}
+	// Начальное состояние: заранее задать решения наименьших подзадач
+	a, b := cost[1], cost[2]
+	// Переход состояний: постепенное решение больших подзадач через меньшие
+	for i := 3; i <= n; i++ {
+		tmp := b
+		b = min(a, tmp) + cost[i]
+		a = tmp
+	}
+	return b
+}

ru/codes/go/chapter_dynamic_programming/min_path_sum.go

@@ -0,0 +1,94 @@
+// File: min_path_sum.go
+// Created Time: 2023-07-23
+// Author: Reanon (793584285@qq.com)
+
+package chapter_dynamic_programming
+
+import "math"
+
+/* Минимальная сумма пути: полный перебор */
+func minPathSumDFS(grid [][]int, i, j int) int {
+	// Если это верхняя левая ячейка, завершить поиск
+	if i == 0 && j == 0 {
+		return grid[0][0]
+	}
+	// Если индексы строки или столбца выходят за границы, вернуть стоимость +∞
+	if i < 0 || j < 0 {
+		return math.MaxInt
+	}
+	// Вычислить минимальную стоимость пути из левого верхнего угла до (i-1, j) и (i, j-1)
+	up := minPathSumDFS(grid, i-1, j)
+	left := minPathSumDFS(grid, i, j-1)
+	// Вернуть минимальную стоимость пути из левого верхнего угла до (i, j)
+	return int(math.Min(float64(left), float64(up))) + grid[i][j]
+}
+
+/* Минимальная сумма пути: поиск с мемоизацией */
+func minPathSumDFSMem(grid, mem [][]int, i, j int) int {
+	// Если это верхняя левая ячейка, завершить поиск
+	if i == 0 && j == 0 {
+		return grid[0][0]
+	}
+	// Если индексы строки или столбца выходят за границы, вернуть стоимость +∞
+	if i < 0 || j < 0 {
+		return math.MaxInt
+	}
+	// Если запись уже есть, вернуть сразу
+	if mem[i][j] != -1 {
+		return mem[i][j]
+	}
+	// Минимальная стоимость пути для левой и верхней ячеек
+	up := minPathSumDFSMem(grid, mem, i-1, j)
+	left := minPathSumDFSMem(grid, mem, i, j-1)
+	// Сохранить и вернуть минимальную стоимость пути из левого верхнего угла до (i, j)
+	mem[i][j] = int(math.Min(float64(left), float64(up))) + grid[i][j]
+	return mem[i][j]
+}
+
+/* Минимальная сумма пути: динамическое программирование */
+func minPathSumDP(grid [][]int) int {
+	n, m := len(grid), len(grid[0])
+	// Инициализация таблицы dp
+	dp := make([][]int, n)
+	for i := 0; i < n; i++ {
+		dp[i] = make([]int, m)
+	}
+	dp[0][0] = grid[0][0]
+	// Переход состояний: первая строка
+	for j := 1; j < m; j++ {
+		dp[0][j] = dp[0][j-1] + grid[0][j]
+	}
+	// Переход состояний: первый столбец
+	for i := 1; i < n; i++ {
+		dp[i][0] = dp[i-1][0] + grid[i][0]
+	}
+	// Переход состояний: остальные строки и столбцы
+	for i := 1; i < n; i++ {
+		for j := 1; j < m; j++ {
+			dp[i][j] = int(math.Min(float64(dp[i][j-1]), float64(dp[i-1][j]))) + grid[i][j]
+		}
+	}
+	return dp[n-1][m-1]
+}
+
+/* Минимальная сумма пути: динамическое программирование с оптимизацией памяти */
+func minPathSumDPComp(grid [][]int) int {
+	n, m := len(grid), len(grid[0])
+	// Инициализация таблицы dp
+	dp := make([]int, m)
+	// Переход состояний: первая строка
+	dp[0] = grid[0][0]
+	for j := 1; j < m; j++ {
+		dp[j] = dp[j-1] + grid[0][j]
+	}
+	// Переход состояний: остальные строки и столбцы
+	for i := 1; i < n; i++ {
+		// Переход состояний: первый столбец
+		dp[0] = dp[0] + grid[i][0]
+		// Переход состояний: остальные столбцы
+		for j := 1; j < m; j++ {
+			dp[j] = int(math.Min(float64(dp[j-1]), float64(dp[j]))) + grid[i][j]
+		}
+	}
+	return dp[m-1]
+}

ru/codes/go/chapter_dynamic_programming/min_path_sum_test.go

@@ -0,0 +1,43 @@
+// File: min_path_sum_test.go
+// Created Time: 2023-07-23
+// Author: Reanon (793584285@qq.com)
+
+package chapter_dynamic_programming
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestMinPathSum(t *testing.T) {
+	grid := [][]int{
+		{1, 3, 1, 5},
+		{2, 2, 4, 2},
+		{5, 3, 2, 1},
+		{4, 3, 5, 2},
+	}
+	n, m := len(grid), len(grid[0])
+
+	// Полный перебор
+	res := minPathSumDFS(grid, n-1, m-1)
+	fmt.Printf("Минимальная сумма пути из левого верхнего угла в правый нижний = %d\n", res)
+
+	// Поиск с мемоизацией
+	mem := make([][]int, n)
+	for i := 0; i < n; i++ {
+		mem[i] = make([]int, m)
+		for j := 0; j < m; j++ {
+			mem[i][j] = -1
+		}
+	}
+	res = minPathSumDFSMem(grid, mem, n-1, m-1)
+	fmt.Printf("Минимальная сумма пути из левого верхнего угла в правый нижний = %d\n", res)
+
+	// Динамическое программирование
+	res = minPathSumDP(grid)
+	fmt.Printf("Минимальная сумма пути из левого верхнего угла в правый нижний = %d\n", res)
+
+	// Динамическое программирование с оптимизацией памяти
+	res = minPathSumDPComp(grid)
+	fmt.Printf("Минимальная сумма пути из левого верхнего угла в правый нижний = %d\n", res)
+}

ru/codes/go/chapter_dynamic_programming/unbounded_knapsack.go

@@ -0,0 +1,50 @@
+// File: unbounded_knapsack.go
+// Created Time: 2023-07-23
+// Author: Reanon (793584285@qq.com)
+
+package chapter_dynamic_programming
+
+import "math"
+
+/* Полный рюкзак: динамическое программирование */
+func unboundedKnapsackDP(wgt, val []int, cap int) int {
+	n := len(wgt)
+	// Инициализация таблицы dp
+	dp := make([][]int, n+1)
+	for i := 0; i <= n; i++ {
+		dp[i] = make([]int, cap+1)
+	}
+	// Переход состояний
+	for i := 1; i <= n; i++ {
+		for c := 1; c <= cap; c++ {
+			if wgt[i-1] > c {
+				// Если вместимость рюкзака превышена, предмет i не выбирать
+				dp[i][c] = dp[i-1][c]
+			} else {
+				// Большее из двух решений: не брать или взять предмет i
+				dp[i][c] = int(math.Max(float64(dp[i-1][c]), float64(dp[i][c-wgt[i-1]]+val[i-1])))
+			}
+		}
+	}
+	return dp[n][cap]
+}
+
+/* Полный рюкзак: динамическое программирование с оптимизацией памяти */
+func unboundedKnapsackDPComp(wgt, val []int, cap int) int {
+	n := len(wgt)
+	// Инициализация таблицы dp
+	dp := make([]int, cap+1)
+	// Переход состояний
+	for i := 1; i <= n; i++ {
+		for c := 1; c <= cap; c++ {
+			if wgt[i-1] > c {
+				// Если вместимость рюкзака превышена, предмет i не выбирать
+				dp[c] = dp[c]
+			} else {
+				// Большее из двух решений: не брать или взять предмет i
+				dp[c] = int(math.Max(float64(dp[c]), float64(dp[c-wgt[i-1]]+val[i-1])))
+			}
+		}
+	}
+	return dp[cap]
+}

ru/codes/go/chapter_graph/graph_adjacency_list.go

@@ -0,0 +1,100 @@
+// File: graph_adjacency_list.go
+// Created Time: 2023-01-31
+// Author: Reanon (793584285@qq.com)
+
+package chapter_graph
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+
+	. "github.com/krahets/hello-algo/pkg"
+)
+
+/* Класс неориентированного графа на основе списка смежности */
+type graphAdjList struct {
+	// Список смежности, где key — вершина, а value — все смежные ей вершины
+	adjList map[Vertex][]Vertex
+}
+
+/* Конструктор */
+func newGraphAdjList(edges [][]Vertex) *graphAdjList {
+	g := &graphAdjList{
+		adjList: make(map[Vertex][]Vertex),
+	}
+	// Добавить все вершины и ребра
+	for _, edge := range edges {
+		g.addVertex(edge[0])
+		g.addVertex(edge[1])
+		g.addEdge(edge[0], edge[1])
+	}
+	return g
+}
+
+/* Получить число вершин */
+func (g *graphAdjList) size() int {
+	return len(g.adjList)
+}
+
+/* Добавление ребра */
+func (g *graphAdjList) addEdge(vet1 Vertex, vet2 Vertex) {
+	_, ok1 := g.adjList[vet1]
+	_, ok2 := g.adjList[vet2]
+	if !ok1 || !ok2 || vet1 == vet2 {
+		panic("error")
+	}
+	// Добавить ребро vet1 - vet2, добавив анонимную struct{}
+	g.adjList[vet1] = append(g.adjList[vet1], vet2)
+	g.adjList[vet2] = append(g.adjList[vet2], vet1)
+}
+
+/* Удаление ребра */
+func (g *graphAdjList) removeEdge(vet1 Vertex, vet2 Vertex) {
+	_, ok1 := g.adjList[vet1]
+	_, ok2 := g.adjList[vet2]
+	if !ok1 || !ok2 || vet1 == vet2 {
+		panic("error")
+	}
+	// Удалить ребро vet1 - vet2
+	g.adjList[vet1] = DeleteSliceElms(g.adjList[vet1], vet2)
+	g.adjList[vet2] = DeleteSliceElms(g.adjList[vet2], vet1)
+}
+
+/* Добавление вершины */
+func (g *graphAdjList) addVertex(vet Vertex) {
+	_, ok := g.adjList[vet]
+	if ok {
+		return
+	}
+	// Добавить новый список в список смежности
+	g.adjList[vet] = make([]Vertex, 0)
+}
+
+/* Удаление вершины */
+func (g *graphAdjList) removeVertex(vet Vertex) {
+	_, ok := g.adjList[vet]
+	if !ok {
+		panic("error")
+	}
+	// Удалить из списка смежности список, соответствующий вершине vet
+	delete(g.adjList, vet)
+	// Обойти списки других вершин и удалить все ребра, содержащие vet
+	for v, list := range g.adjList {
+		g.adjList[v] = DeleteSliceElms(list, vet)
+	}
+}
+
+/* Вывести список смежности */
+func (g *graphAdjList) print() {
+	var builder strings.Builder
+	fmt.Printf("Список смежности = \n")
+	for k, v := range g.adjList {
+		builder.WriteString("\t\t" + strconv.Itoa(k.Val) + ": ")
+		for _, vet := range v {
+			builder.WriteString(strconv.Itoa(vet.Val) + " ")
+		}
+		fmt.Println(builder.String())
+		builder.Reset()
+	}
+}

ru/codes/go/chapter_graph/graph_adjacency_list_test.go

@@ -0,0 +1,45 @@
+// File: graph_adjacency_list_test.go
+// Created Time: 2023-01-31
+// Author: Reanon (793584285@qq.com)
+
+package chapter_graph
+
+import (
+	"fmt"
+	"testing"
+
+	. "github.com/krahets/hello-algo/pkg"
+)
+
+func TestGraphAdjList(t *testing.T) {
+	/* Инициализация неориентированного графа */
+	v := ValsToVets([]int{1, 3, 2, 5, 4})
+	edges := [][]Vertex{{v[0], v[1]}, {v[0], v[3]}, {v[1], v[2]}, {v[2], v[3]}, {v[2], v[4]}, {v[3], v[4]}}
+	graph := newGraphAdjList(edges)
+	fmt.Println("Граф после инициализации:")
+	graph.print()
+
+	/* Добавление ребра */
+	// Вершины 1 и 2 соответствуют v[0] и v[2]
+	graph.addEdge(v[0], v[2])
+	fmt.Println("\nГраф после добавления ребра 1-2")
+	graph.print()
+
+	/* Удаление ребра */
+	// Вершины 1 и 3 соответствуют v[0] и v[1]
+	graph.removeEdge(v[0], v[1])
+	fmt.Println("\nГраф после удаления ребра 1-3")
+	graph.print()
+
+	/* Добавление вершины */
+	v5 := NewVertex(6)
+	graph.addVertex(v5)
+	fmt.Println("\nГраф после добавления вершины 6")
+	graph.print()
+
+	/* Удаление вершины */
+	// Вершина 3 соответствует v[1]
+	graph.removeVertex(v[1])
+	fmt.Println("\nГраф после удаления вершины 3")
+	graph.print()
+}

ru/codes/go/chapter_graph/graph_adjacency_matrix.go

@@ -0,0 +1,102 @@
+// File: graph_adjacency_matrix.go
+// Created Time: 2023-01-31
+// Author: Reanon (793584285@qq.com)
+
+package chapter_graph
+
+import "fmt"
+
+/* Класс неориентированного графа на основе матрицы смежности */
+type graphAdjMat struct {
+	// Список вершин: элементы представляют «значения вершин», а индексы — «индексы вершин»
+	vertices []int
+	// Матрица смежности, где индексы строк и столбцов соответствуют «индексам вершин»
+	adjMat [][]int
+}
+
+/* Конструктор */
+func newGraphAdjMat(vertices []int, edges [][]int) *graphAdjMat {
+	// Добавление вершины
+	n := len(vertices)
+	adjMat := make([][]int, n)
+	for i := range adjMat {
+		adjMat[i] = make([]int, n)
+	}
+	// Инициализировать граф
+	g := &graphAdjMat{
+		vertices: vertices,
+		adjMat:   adjMat,
+	}
+	// Добавить ребра
+	// Обратите внимание: элементы edges представляют собой индексы вершин, то есть соответствуют индексам элементов vertices
+	for i := range edges {
+		g.addEdge(edges[i][0], edges[i][1])
+	}
+	return g
+}
+
+/* Получить число вершин */
+func (g *graphAdjMat) size() int {
+	return len(g.vertices)
+}
+
+/* Добавление вершины */
+func (g *graphAdjMat) addVertex(val int) {
+	n := g.size()
+	// Добавить значение новой вершины в список вершин
+	g.vertices = append(g.vertices, val)
+	// Добавить строку в матрицу смежности
+	newRow := make([]int, n)
+	g.adjMat = append(g.adjMat, newRow)
+	// Добавить столбец в матрицу смежности
+	for i := range g.adjMat {
+		g.adjMat[i] = append(g.adjMat[i], 0)
+	}
+}
+
+/* Удаление вершины */
+func (g *graphAdjMat) removeVertex(index int) {
+	if index >= g.size() {
+		return
+	}
+	// Удалить вершину с индексом index из списка вершин
+	g.vertices = append(g.vertices[:index], g.vertices[index+1:]...)
+	// Удалить строку с индексом index из матрицы смежности
+	g.adjMat = append(g.adjMat[:index], g.adjMat[index+1:]...)
+	// Удалить столбец с индексом index из матрицы смежности
+	for i := range g.adjMat {
+		g.adjMat[i] = append(g.adjMat[i][:index], g.adjMat[i][index+1:]...)
+	}
+}
+
+/* Добавление ребра */
+// Параметры i и j соответствуют индексам элементов vertices
+func (g *graphAdjMat) addEdge(i, j int) {
+	// Обработка выхода индекса за границы и случая равенства
+	if i < 0 || j < 0 || i >= g.size() || j >= g.size() || i == j {
+		fmt.Errorf("%s", "Index Out Of Bounds Exception")
+	}
+	// В неориентированном графе матрица смежности симметрична относительно главной диагонали, то есть выполняется (i, j) == (j, i)
+	g.adjMat[i][j] = 1
+	g.adjMat[j][i] = 1
+}
+
+/* Удаление ребра */
+// Параметры i и j соответствуют индексам элементов vertices
+func (g *graphAdjMat) removeEdge(i, j int) {
+	// Обработка выхода индекса за границы и случая равенства
+	if i < 0 || j < 0 || i >= g.size() || j >= g.size() || i == j {
+		fmt.Errorf("%s", "Index Out Of Bounds Exception")
+	}
+	g.adjMat[i][j] = 0
+	g.adjMat[j][i] = 0
+}
+
+/* Вывести матрицу смежности */
+func (g *graphAdjMat) print() {
+	fmt.Printf("\tСписок вершин = %v\n", g.vertices)
+	fmt.Printf("\tМатрица смежности = \n")
+	for i := range g.adjMat {
+		fmt.Printf("\t\t\t%v\n", g.adjMat[i])
+	}
+}

ru/codes/go/chapter_graph/graph_adjacency_matrix_test.go

@@ -0,0 +1,43 @@
+// File: graph_adjacency_matrix_test.go
+// Created Time: 2023-01-31
+// Author: Reanon (793584285@qq.com)
+
+package chapter_graph
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestGraphAdjMat(t *testing.T) {
+	/* Инициализация неориентированного графа */
+	// Обратите внимание: элементы edges представляют индексы вершин, то есть соответствуют индексам элементов vertices
+	vertices := []int{1, 3, 2, 5, 4}
+	edges := [][]int{{0, 1}, {1, 2}, {2, 3}, {0, 3}, {2, 4}, {3, 4}}
+	graph := newGraphAdjMat(vertices, edges)
+	fmt.Println("Граф после инициализации:")
+	graph.print()
+
+	/* Добавление ребра */
+	// Индексы вершин 1 и 2 равны 0 и 2 соответственно
+	graph.addEdge(0, 2)
+	fmt.Println("Граф после добавления ребра 1-2")
+	graph.print()
+
+	/* Удаление ребра */
+	// Индексы вершин 1 и 3 равны 0 и 1 соответственно
+	graph.removeEdge(0, 1)
+	fmt.Println("Граф после удаления ребра 1-3")
+	graph.print()
+
+	/* Добавление вершины */
+	graph.addVertex(6)
+	fmt.Println("Граф после добавления вершины 6")
+	graph.print()
+
+	/* Удаление вершины */
+	// Индекс вершины 3 равен 1
+	graph.removeVertex(1)
+	fmt.Println("Граф после удаления вершины 3")
+	graph.print()
+}

ru/codes/go/chapter_graph/graph_bfs.go

@@ -0,0 +1,41 @@
+// File: graph_bfs.go
+// Created Time: 2023-02-18
+// Author: Reanon (793584285@qq.com)
+
+package chapter_graph
+
+import (
+	. "github.com/krahets/hello-algo/pkg"
+)
+
+/* Обход в ширину */
+// Использовать список смежности для представления графа, чтобы получить все смежные вершины заданной вершины
+func graphBFS(g *graphAdjList, startVet Vertex) []Vertex {
+	// Последовательность обхода вершин
+	res := make([]Vertex, 0)
+	// Хеш-множество для хранения уже посещенных вершин
+	visited := make(map[Vertex]struct{})
+	visited[startVet] = struct{}{}
+	// Очередь используется для реализации BFS, срез используется для имитации очереди
+	queue := make([]Vertex, 0)
+	queue = append(queue, startVet)
+	// Начиная с вершины vet, продолжать цикл, пока не будут посещены все вершины
+	for len(queue) > 0 {
+		// Извлечь головную вершину из очереди
+		vet := queue[0]
+		queue = queue[1:]
+		// Отметить посещенную вершину
+		res = append(res, vet)
+		// Обойти все смежные вершины данной вершины
+		for _, adjVet := range g.adjList[vet] {
+			_, isExist := visited[adjVet]
+			// Помещать в очередь только непосещенные вершины
+			if !isExist {
+				queue = append(queue, adjVet)
+				visited[adjVet] = struct{}{}
+			}
+		}
+	}
+	// Вернуть последовательность обхода вершин
+	return res
+}

ru/codes/go/chapter_graph/graph_bfs_test.go

@@ -0,0 +1,29 @@
+// File: graph_bfs_test.go
+// Created Time: 2023-02-18
+// Author: Reanon (793584285@qq.com)
+
+package chapter_graph
+
+import (
+	"fmt"
+	"testing"
+
+	. "github.com/krahets/hello-algo/pkg"
+)
+
+func TestGraphBFS(t *testing.T) {
+	/* Инициализация неориентированного графа */
+	vets := ValsToVets([]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9})
+	edges := [][]Vertex{
+		{vets[0], vets[1]}, {vets[0], vets[3]}, {vets[1], vets[2]}, {vets[1], vets[4]},
+		{vets[2], vets[5]}, {vets[3], vets[4]}, {vets[3], vets[6]}, {vets[4], vets[5]},
+		{vets[4], vets[7]}, {vets[5], vets[8]}, {vets[6], vets[7]}, {vets[7], vets[8]}}
+	graph := newGraphAdjList(edges)
+	fmt.Println("Граф после инициализации:")
+	graph.print()
+
+	/* Обход в ширину */
+	res := graphBFS(graph, vets[0])
+	fmt.Println("Последовательность вершин при обходе в ширину (BFS):")
+	PrintSlice(VetsToVals(res))
+}

ru/codes/go/chapter_graph/graph_dfs.go

@@ -0,0 +1,36 @@
+// File: graph_dfs.go
+// Created Time: 2023-02-18
+// Author: Reanon (793584285@qq.com)
+
+package chapter_graph
+
+import (
+	. "github.com/krahets/hello-algo/pkg"
+)
+
+/* Вспомогательная функция обхода в глубину */
+func dfs(g *graphAdjList, visited map[Vertex]struct{}, res *[]Vertex, vet Vertex) {
+	// Операция append возвращает новую ссылку, поэтому исходную ссылку нужно заново присвоить новому срезу
+	*res = append(*res, vet)
+	visited[vet] = struct{}{}
+	// Обойти все смежные вершины данной вершины
+	for _, adjVet := range g.adjList[vet] {
+		_, isExist := visited[adjVet]
+		// Рекурсивно обходить смежные вершины
+		if !isExist {
+			dfs(g, visited, res, adjVet)
+		}
+	}
+}
+
+/* Обход в глубину */
+// Использовать список смежности для представления графа, чтобы получить все смежные вершины заданной вершины
+func graphDFS(g *graphAdjList, startVet Vertex) []Vertex {
+	// Последовательность обхода вершин
+	res := make([]Vertex, 0)
+	// Хеш-множество для хранения уже посещенных вершин
+	visited := make(map[Vertex]struct{})
+	dfs(g, visited, &res, startVet)
+	// Вернуть последовательность обхода вершин
+	return res
+}

ru/codes/go/chapter_graph/graph_dfs_test.go

@@ -0,0 +1,28 @@
+// File: graph_dfs_test.go
+// Created Time: 2023-02-18
+// Author: Reanon (793584285@qq.com)
+
+package chapter_graph
+
+import (
+	"fmt"
+	"testing"
+
+	. "github.com/krahets/hello-algo/pkg"
+)
+
+func TestGraphDFS(t *testing.T) {
+	/* Инициализация неориентированного графа */
+	vets := ValsToVets([]int{0, 1, 2, 3, 4, 5, 6})
+	edges := [][]Vertex{
+		{vets[0], vets[1]}, {vets[0], vets[3]}, {vets[1], vets[2]},
+		{vets[2], vets[5]}, {vets[4], vets[5]}, {vets[5], vets[6]}}
+	graph := newGraphAdjList(edges)
+	fmt.Println("Граф после инициализации:")
+	graph.print()
+
+	/* Обход в глубину */
+	res := graphDFS(graph, vets[0])
+	fmt.Println("Последовательность вершин при обходе в глубину (DFS):")
+	PrintSlice(VetsToVals(res))
+}

ru/codes/go/chapter_greedy/coin_change_greedy.go

@@ -0,0 +1,27 @@
+// File: coin_change_greedy.go
+// Created Time: 2023-07-23
+// Author: Reanon (793584285@qq.com)
+
+package chapter_greedy
+
+/* Размен монет: жадный алгоритм */
+func coinChangeGreedy(coins []int, amt int) int {
+	// Предположить, что список coins упорядочен
+	i := len(coins) - 1
+	count := 0
+	// Циклически выполнять жадный выбор, пока не останется суммы
+	for amt > 0 {
+		// Найти монету, которая меньше остатка суммы и наиболее к нему близка
+		for i > 0 && coins[i] > amt {
+			i--
+		}
+		// Выбрать coins[i]
+		amt -= coins[i]
+		count++
+	}
+	// Если допустимое решение не найдено, вернуть -1
+	if amt != 0 {
+		return -1
+	}
+	return count
+}

ru/codes/go/chapter_greedy/coin_change_greedy_test.go

@@ -0,0 +1,35 @@
+// File: coin_change_greedy_test.go
+// Created Time: 2023-07-23
+// Author: Reanon (793584285@qq.com)
+
+package chapter_greedy
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestCoinChangeGreedy(t *testing.T) {
+	// Жадный подход: гарантирует нахождение глобально оптимального решения
+	coins := []int{1, 5, 10, 20, 50, 100}
+	amt := 186
+	res := coinChangeGreedy(coins, amt)
+	fmt.Printf("coins = %v, amt = %d\n", coins, amt)
+	fmt.Printf("Минимальное число монет для набора суммы %d = %d\n", amt, res)
+
+	// Жадный подход: не гарантирует нахождение глобально оптимального решения
+	coins = []int{1, 20, 50}
+	amt = 60
+	res = coinChangeGreedy(coins, amt)
+	fmt.Printf("coins = %v, amt = %d\n", coins, amt)
+	fmt.Printf("Минимальное число монет для набора суммы %d = %d\n", amt, res)
+	fmt.Println("На самом деле минимум равен 3: 20 + 20 + 20")
+
+	// Жадный подход: не гарантирует нахождение глобально оптимального решения
+	coins = []int{1, 49, 50}
+	amt = 98
+	res = coinChangeGreedy(coins, amt)
+	fmt.Printf("coins = %v, amt = %d\n", coins, amt)
+	fmt.Printf("Минимальное число монет для набора суммы %d = %d\n", amt, res)
+	fmt.Println("На самом деле минимум равен 2: 49 + 49")
+}

ru/codes/go/chapter_greedy/fractional_knapsack.go

@@ -0,0 +1,41 @@
+// File: fractional_knapsack.go
+// Created Time: 2023-07-23
+// Author: Reanon (793584285@qq.com)
+
+package chapter_greedy
+
+import "sort"
+
+/* Предмет */
+type Item struct {
+	w int // Вес предмета
+	v int // Стоимость предмета
+}
+
+/* Дробный рюкзак: жадный алгоритм */
+func fractionalKnapsack(wgt []int, val []int, cap int) float64 {
+	// Создать список предметов с двумя свойствами: вес и стоимость
+	items := make([]Item, len(wgt))
+	for i := 0; i < len(wgt); i++ {
+		items[i] = Item{wgt[i], val[i]}
+	}
+	// Отсортировать по удельной стоимости item.v / item.w в порядке убывания
+	sort.Slice(items, func(i, j int) bool {
+		return float64(items[i].v)/float64(items[i].w) > float64(items[j].v)/float64(items[j].w)
+	})
+	// Циклический жадный выбор
+	res := 0.0
+	for _, item := range items {
+		if item.w <= cap {
+			// Если оставшейся вместимости достаточно, положить в рюкзак текущий предмет целиком
+			res += float64(item.v)
+			cap -= item.w
+		} else {
+			// Если оставшейся вместимости недостаточно, положить в рюкзак часть текущего предмета
+			res += float64(item.v) / float64(item.w) * float64(cap)
+			// Свободной вместимости больше не осталось, поэтому выйти из цикла
+			break
+		}
+	}
+	return res
+}

ru/codes/go/chapter_greedy/fractional_knapsack_test.go

@@ -0,0 +1,20 @@
+// File: fractional_knapsack_test.go
+// Created Time: 2023-07-23
+// Author: Reanon (793584285@qq.com)
+
+package chapter_greedy
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestFractionalKnapsack(t *testing.T) {
+	wgt := []int{10, 20, 30, 40, 50}
+	val := []int{50, 120, 150, 210, 240}
+	capacity := 50
+
+	// Жадный алгоритм
+	res := fractionalKnapsack(wgt, val, capacity)
+	fmt.Println("Максимальная стоимость предметов без превышения вместимости рюкзака =", res)
+}

ru/codes/go/chapter_greedy/max_capacity.go

@@ -0,0 +1,28 @@
+// File: max_capacity.go
+// Created Time: 2023-07-23
+// Author: Reanon (793584285@qq.com)
+
+package chapter_greedy
+
+import "math"
+
+/* Максимальная вместимость: жадный алгоритм */
+func maxCapacity(ht []int) int {
+	// Инициализировать i и j так, чтобы они располагались по двум концам массива
+	i, j := 0, len(ht)-1
+	// Начальная максимальная вместимость равна 0
+	res := 0
+	// Выполнять жадный выбор в цикле, пока две доски не встретятся
+	for i < j {
+		// Обновить максимальную вместимость
+		capacity := int(math.Min(float64(ht[i]), float64(ht[j]))) * (j - i)
+		res = int(math.Max(float64(res), float64(capacity)))
+		// Сдвигать внутрь более короткую сторону
+		if ht[i] < ht[j] {
+			i++
+		} else {
+			j--
+		}
+	}
+	return res
+}

ru/codes/go/chapter_greedy/max_capacity_test.go

@@ -0,0 +1,18 @@
+// File: max_capacity_test.go
+// Created Time: 2023-07-23
+// Author: Reanon (793584285@qq.com)
+
+package chapter_greedy
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestMaxCapacity(t *testing.T) {
+	ht := []int{3, 8, 5, 2, 7, 7, 3, 4}
+
+	// Жадный алгоритм
+	res := maxCapacity(ht)
+	fmt.Println("Максимальная вместимость =", res)
+}

ru/codes/go/chapter_greedy/max_product_cutting.go

@@ -0,0 +1,28 @@
+// File: max_product_cutting.go
+// Created Time: 2023-07-23
+// Author: Reanon (793584285@qq.com)
+
+package chapter_greedy
+
+import "math"
+
+/* Максимальное произведение разрезания: жадный алгоритм */
+func maxProductCutting(n int) int {
+	// Когда n <= 3, обязательно нужно выделить одну 1
+	if n <= 3 {
+		return 1 * (n - 1)
+	}
+	// Жадно выделить множители 3, где a — число троек, а b — остаток
+	a := n / 3
+	b := n % 3
+	if b == 1 {
+		// Если остаток равен 1, преобразовать одну пару 1 * 3 в 2 * 2
+		return int(math.Pow(3, float64(a-1))) * 2 * 2
+	}
+	if b == 2 {
+		// Если остаток равен 2, ничего не делать
+		return int(math.Pow(3, float64(a))) * 2
+	}
+	// Если остаток равен 0, ничего не делать
+	return int(math.Pow(3, float64(a)))
+}

ru/codes/go/chapter_greedy/max_product_cutting_test.go

@@ -0,0 +1,17 @@
+// File: max_product_cutting_test.go
+// Created Time: 2023-07-23
+// Author: Reanon (793584285@qq.com)
+
+package chapter_greedy
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestMaxProductCutting(t *testing.T) {
+	n := 58
+	// Жадный алгоритм
+	res := maxProductCutting(n)
+	fmt.Println("Максимальное произведение после разрезания =", res)
+}

ru/codes/go/chapter_hashing/array_hash_map.go

@@ -0,0 +1,97 @@
+// File: array_hash_map.go
+// Created Time: 2022-12-14
+// Author: msk397 (machangxinq@gmail.com)
+
+package chapter_hashing
+
+import "fmt"
+
+/* Пара ключ-значение */
+type pair struct {
+	key int
+	val string
+}
+
+/* Хеш-таблица на основе массива */
+type arrayHashMap struct {
+	buckets []*pair
+}
+
+/* Инициализация хеш-таблицы */
+func newArrayHashMap() *arrayHashMap {
+	// Инициализировать массив, содержащий 100 корзин
+	buckets := make([]*pair, 100)
+	return &arrayHashMap{buckets: buckets}
+}
+
+/* Хеш-функция */
+func (a *arrayHashMap) hashFunc(key int) int {
+	index := key % 100
+	return index
+}
+
+/* Операция поиска */
+func (a *arrayHashMap) get(key int) string {
+	index := a.hashFunc(key)
+	pair := a.buckets[index]
+	if pair == nil {
+		return "Not Found"
+	}
+	return pair.val
+}
+
+/* Операция добавления */
+func (a *arrayHashMap) put(key int, val string) {
+	pair := &pair{key: key, val: val}
+	index := a.hashFunc(key)
+	a.buckets[index] = pair
+}
+
+/* Операция удаления */
+func (a *arrayHashMap) remove(key int) {
+	index := a.hashFunc(key)
+	// Присвоить nil, что означает удаление
+	a.buckets[index] = nil
+}
+
+/* Получить все ключи */
+func (a *arrayHashMap) pairSet() []*pair {
+	var pairs []*pair
+	for _, pair := range a.buckets {
+		if pair != nil {
+			pairs = append(pairs, pair)
+		}
+	}
+	return pairs
+}
+
+/* Получить все ключи */
+func (a *arrayHashMap) keySet() []int {
+	var keys []int
+	for _, pair := range a.buckets {
+		if pair != nil {
+			keys = append(keys, pair.key)
+		}
+	}
+	return keys
+}
+
+/* Получить все значения */
+func (a *arrayHashMap) valueSet() []string {
+	var values []string
+	for _, pair := range a.buckets {
+		if pair != nil {
+			values = append(values, pair.val)
+		}
+	}
+	return values
+}
+
+/* Вывести хеш-таблицу */
+func (a *arrayHashMap) print() {
+	for _, pair := range a.buckets {
+		if pair != nil {
+			fmt.Println(pair.key, "->", pair.val)
+		}
+	}
+}

ru/codes/go/chapter_hashing/array_hash_map_test.go

@@ -0,0 +1,52 @@
+// File: array_hash_map_test.go
+// Created Time: 2022-12-14
+// Author: msk397 (machangxinq@gmail.com)
+
+package chapter_hashing
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestArrayHashMap(t *testing.T) {
+	/* Инициализация хеш-таблицы */
+	hmap := newArrayHashMap()
+
+	/* Операция добавления */
+	// Добавить пару (key, value) в хеш-таблицу
+	hmap.put(12836, "Сяо Ха")
+	hmap.put(15937, "Сяо Ло")
+	hmap.put(16750, "Сяо Суань")
+	hmap.put(13276, "Сяо Фа")
+	hmap.put(10583, "Сяо Я")
+	fmt.Println("\nПосле добавления хеш-таблица имеет вид\nКлюч -> Значение")
+	hmap.print()
+
+	/* Операция поиска */
+	// Ввести в хеш-таблицу ключ key и получить значение value
+	name := hmap.get(15937)
+	fmt.Println("\nДля номера 15937 найдено имя " + name)
+
+	/* Операция удаления */
+	// Удалить пару (key, value) из хеш-таблицы
+	hmap.remove(10583)
+	fmt.Println("\nПосле удаления 10583 хеш-таблица имеет вид\nКлюч -> Значение")
+	hmap.print()
+
+	/* Обход хеш-таблицы */
+	fmt.Println("\nОтдельный обход пар ключ-значение")
+	for _, kv := range hmap.pairSet() {
+		fmt.Println(kv.key, " -> ", kv.val)
+	}
+
+	fmt.Println("\nОтдельный обход ключей")
+	for _, key := range hmap.keySet() {
+		fmt.Println(key)
+	}
+
+	fmt.Println("\nОтдельный обход значений")
+	for _, val := range hmap.valueSet() {
+		fmt.Println(val)
+	}
+}

ru/codes/go/chapter_hashing/hash_collision_test.go

@@ -0,0 +1,62 @@
+// File: hash_collision_test.go
+// Created Time: 2022-12-14
+// Author: msk397 (machangxinq@gmail.com)
+
+package chapter_hashing
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestHashMapChaining(t *testing.T) {
+	/* Инициализация хеш-таблицы */
+	hmap := newHashMapChaining()
+
+	/* Операция добавления */
+	// Добавить пару (key, value) в хеш-таблицу
+	hmap.put(12836, "Сяо Ха")
+	hmap.put(15937, "Сяо Ло")
+	hmap.put(16750, "Сяо Суань")
+	hmap.put(13276, "Сяо Фа")
+	hmap.put(10583, "Сяо Я")
+	fmt.Println("\nПосле добавления хеш-таблица имеет вид\nКлюч -> Значение")
+	hmap.print()
+
+	/* Операция поиска */
+	// Ввести в хеш-таблицу ключ key и получить значение value
+	name := hmap.get(15937)
+	fmt.Println("\nДля номера 15937 найдено имя", name)
+
+	/* Операция удаления */
+	// Удалить пару (key, value) из хеш-таблицы
+	hmap.remove(12836)
+	fmt.Println("\nПосле удаления 12836 хеш-таблица имеет вид\nКлюч -> Значение")
+	hmap.print()
+}
+
+func TestHashMapOpenAddressing(t *testing.T) {
+	/* Инициализация хеш-таблицы */
+	hmap := newHashMapOpenAddressing()
+
+	/* Операция добавления */
+	// Добавить пару (key, value) в хеш-таблицу
+	hmap.put(12836, "Сяо Ха")
+	hmap.put(15937, "Сяо Ло")
+	hmap.put(16750, "Сяо Суань")
+	hmap.put(13276, "Сяо Фа")
+	hmap.put(10583, "Сяо Я")
+	fmt.Println("\nПосле добавления хеш-таблица имеет вид\nКлюч -> Значение")
+	hmap.print()
+
+	/* Операция поиска */
+	// Ввести в хеш-таблицу ключ key и получить значение value
+	name := hmap.get(13276)
+	fmt.Println("\nДля номера 13276 найдено имя", name)
+
+	/* Операция удаления */
+	// Удалить пару (key, value) из хеш-таблицы
+	hmap.remove(16750)
+	fmt.Println("\nПосле удаления 16750 хеш-таблица имеет вид\nКлюч -> Значение")
+	hmap.print()
+}

ru/codes/go/chapter_hashing/hash_map_chaining.go

@@ -0,0 +1,134 @@
+// File: hash_map_chaining.go
+// Created Time: 2023-06-23
+// Author: Reanon (793584285@qq.com)
+
+package chapter_hashing
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+/* Хеш-таблица с цепочками */
+type hashMapChaining struct {
+	size        int      // Число пар ключ-значение
+	capacity    int      // Вместимость хеш-таблицы
+	loadThres   float64  // Порог коэффициента загрузки для запуска расширения
+	extendRatio int      // Коэффициент расширения
+	buckets     [][]pair // Массив корзин
+}
+
+/* Конструктор */
+func newHashMapChaining() *hashMapChaining {
+	buckets := make([][]pair, 4)
+	for i := 0; i < 4; i++ {
+		buckets[i] = make([]pair, 0)
+	}
+	return &hashMapChaining{
+		size:        0,
+		capacity:    4,
+		loadThres:   2.0 / 3.0,
+		extendRatio: 2,
+		buckets:     buckets,
+	}
+}
+
+/* Хеш-функция */
+func (m *hashMapChaining) hashFunc(key int) int {
+	return key % m.capacity
+}
+
+/* Коэффициент загрузки */
+func (m *hashMapChaining) loadFactor() float64 {
+	return float64(m.size) / float64(m.capacity)
+}
+
+/* Операция поиска */
+func (m *hashMapChaining) get(key int) string {
+	idx := m.hashFunc(key)
+	bucket := m.buckets[idx]
+	// Обойти корзину; если найден key, вернуть соответствующее val
+	for _, p := range bucket {
+		if p.key == key {
+			return p.val
+		}
+	}
+	// Если key не найден, вернуть пустую строку
+	return ""
+}
+
+/* Операция добавления */
+func (m *hashMapChaining) put(key int, val string) {
+	// Когда коэффициент загрузки превышает порог, выполнить расширение
+	if m.loadFactor() > m.loadThres {
+		m.extend()
+	}
+	idx := m.hashFunc(key)
+	// Обойти корзину; если встретился указанный key, обновить соответствующее val и вернуть
+	for i := range m.buckets[idx] {
+		if m.buckets[idx][i].key == key {
+			m.buckets[idx][i].val = val
+			return
+		}
+	}
+	// Если такого key нет, добавить пару ключ-значение в конец
+	p := pair{
+		key: key,
+		val: val,
+	}
+	m.buckets[idx] = append(m.buckets[idx], p)
+	m.size += 1
+}
+
+/* Операция удаления */
+func (m *hashMapChaining) remove(key int) {
+	idx := m.hashFunc(key)
+	// Обойти корзину и удалить из нее пару ключ-значение
+	for i, p := range m.buckets[idx] {
+		if p.key == key {
+			// Удаление из среза
+			m.buckets[idx] = append(m.buckets[idx][:i], m.buckets[idx][i+1:]...)
+			m.size -= 1
+			break
+		}
+	}
+}
+
+/* Расширить хеш-таблицу */
+func (m *hashMapChaining) extend() {
+	// Временно сохранить исходную хеш-таблицу
+	tmpBuckets := make([][]pair, len(m.buckets))
+	for i := 0; i < len(m.buckets); i++ {
+		tmpBuckets[i] = make([]pair, len(m.buckets[i]))
+		copy(tmpBuckets[i], m.buckets[i])
+	}
+	// Инициализация новой хеш-таблицы после расширения
+	m.capacity *= m.extendRatio
+	m.buckets = make([][]pair, m.capacity)
+	for i := 0; i < m.capacity; i++ {
+		m.buckets[i] = make([]pair, 0)
+	}
+	m.size = 0
+	// Перенести пары ключ-значение из исходной хеш-таблицы в новую
+	for _, bucket := range tmpBuckets {
+		for _, p := range bucket {
+			m.put(p.key, p.val)
+		}
+	}
+}
+
+/* Вывести хеш-таблицу */
+func (m *hashMapChaining) print() {
+	var builder strings.Builder
+
+	for _, bucket := range m.buckets {
+		builder.WriteString("[")
+		for _, p := range bucket {
+			builder.WriteString(strconv.Itoa(p.key) + " -> " + p.val + " ")
+		}
+		builder.WriteString("]")
+		fmt.Println(builder.String())
+		builder.Reset()
+	}
+}

ru/codes/go/chapter_hashing/hash_map_open_addressing.go

@@ -0,0 +1,126 @@
+// File: hash_map_open_addressing.go
+// Created Time: 2023-06-23
+// Author: Reanon (793584285@qq.com)
+
+package chapter_hashing
+
+import (
+	"fmt"
+)
+
+/* Хеш-таблица с открытой адресацией */
+type hashMapOpenAddressing struct {
+	size        int     // Число пар ключ-значение
+	capacity    int     // Вместимость хеш-таблицы
+	loadThres   float64 // Порог коэффициента загрузки для запуска расширения
+	extendRatio int     // Коэффициент расширения
+	buckets     []*pair // Массив корзин
+	TOMBSTONE   *pair   // Удалить метку
+}
+
+/* Конструктор */
+func newHashMapOpenAddressing() *hashMapOpenAddressing {
+	return &hashMapOpenAddressing{
+		size:        0,
+		capacity:    4,
+		loadThres:   2.0 / 3.0,
+		extendRatio: 2,
+		buckets:     make([]*pair, 4),
+		TOMBSTONE:   &pair{-1, "-1"},
+	}
+}
+
+/* Хеш-функция */
+func (h *hashMapOpenAddressing) hashFunc(key int) int {
+	return key % h.capacity // Вычислить хеш-значение по ключу
+}
+
+/* Коэффициент загрузки */
+func (h *hashMapOpenAddressing) loadFactor() float64 {
+	return float64(h.size) / float64(h.capacity) // Вычислить текущий коэффициент загрузки
+}
+
+/* Найти индекс корзины, соответствующий key */
+func (h *hashMapOpenAddressing) findBucket(key int) int {
+	index := h.hashFunc(key) // Получить начальный индекс
+	firstTombstone := -1     // Запомнить положение первого TOMBSTONE
+	for h.buckets[index] != nil {
+		if h.buckets[index].key == key {
+			if firstTombstone != -1 {
+				// Если ранее встретилась метка удаления, переместить пару ключ-значение на этот индекс
+				h.buckets[firstTombstone] = h.buckets[index]
+				h.buckets[index] = h.TOMBSTONE
+				return firstTombstone // Вернуть индекс корзины после перемещения
+			}
+			return index // Вернуть найденный индекс
+		}
+		if firstTombstone == -1 && h.buckets[index] == h.TOMBSTONE {
+			firstTombstone = index // Запомнить положение первой метки удаления
+		}
+		index = (index + 1) % h.capacity // Линейное пробирование: при выходе за хвост вернуться к началу
+	}
+	// Если key не существует, вернуть индекс точки добавления
+	if firstTombstone != -1 {
+		return firstTombstone
+	}
+	return index
+}
+
+/* Операция поиска */
+func (h *hashMapOpenAddressing) get(key int) string {
+	index := h.findBucket(key) // Найти индекс корзины, соответствующий key
+	if h.buckets[index] != nil && h.buckets[index] != h.TOMBSTONE {
+		return h.buckets[index].val // Если пара ключ-значение найдена, вернуть соответствующее val
+	}
+	return "" // Если пара ключ-значение не существует, вернуть ""
+}
+
+/* Операция добавления */
+func (h *hashMapOpenAddressing) put(key int, val string) {
+	if h.loadFactor() > h.loadThres {
+		h.extend() // Когда коэффициент загрузки превышает порог, выполнить расширение
+	}
+	index := h.findBucket(key) // Найти индекс корзины, соответствующий key
+	if h.buckets[index] == nil || h.buckets[index] == h.TOMBSTONE {
+		h.buckets[index] = &pair{key, val} // Если пары ключ-значение нет, добавить ее
+		h.size++
+	} else {
+		h.buckets[index].val = val // Если пара ключ-значение найдена, перезаписать val
+	}
+}
+
+/* Операция удаления */
+func (h *hashMapOpenAddressing) remove(key int) {
+	index := h.findBucket(key) // Найти индекс корзины, соответствующий key
+	if h.buckets[index] != nil && h.buckets[index] != h.TOMBSTONE {
+		h.buckets[index] = h.TOMBSTONE // Если пара ключ-значение найдена, заменить ее меткой удаления
+		h.size--
+	}
+}
+
+/* Расширить хеш-таблицу */
+func (h *hashMapOpenAddressing) extend() {
+	oldBuckets := h.buckets               // Временно сохранить исходную хеш-таблицу
+	h.capacity *= h.extendRatio           // Обновить емкость
+	h.buckets = make([]*pair, h.capacity) // Инициализация новой хеш-таблицы после расширения
+	h.size = 0                            // Сбросить размер
+	// Перенести пары ключ-значение из исходной хеш-таблицы в новую
+	for _, pair := range oldBuckets {
+		if pair != nil && pair != h.TOMBSTONE {
+			h.put(pair.key, pair.val)
+		}
+	}
+}
+
+/* Вывести хеш-таблицу */
+func (h *hashMapOpenAddressing) print() {
+	for _, pair := range h.buckets {
+		if pair == nil {
+			fmt.Println("nil")
+		} else if pair == h.TOMBSTONE {
+			fmt.Println("TOMBSTONE")
+		} else {
+			fmt.Printf("%d -> %s\n", pair.key, pair.val)
+		}
+	}
+}

ru/codes/go/chapter_hashing/hash_map_test.go

@@ -0,0 +1,74 @@
+// File: hash_map_test.go
+// Created Time: 2022-12-14
+// Author: msk397 (machangxinq@gmail.com)
+
+package chapter_hashing
+
+import (
+	"fmt"
+	"strconv"
+	"testing"
+
+	. "github.com/krahets/hello-algo/pkg"
+)
+
+func TestHashMap(t *testing.T) {
+	/* Инициализация хеш-таблицы */
+	hmap := make(map[int]string)
+
+	/* Операция добавления */
+	// Добавить пару (key, value) в хеш-таблицу
+	hmap[12836] = "Сяо Ха"
+	hmap[15937] = "Сяо Ло"
+	hmap[16750] = "Сяо Суань"
+	hmap[13276] = "Сяо Фа"
+	hmap[10583] = "Сяо Я"
+	fmt.Println("\nПосле добавления хеш-таблица имеет вид\nКлюч -> Значение")
+	PrintMap(hmap)
+
+	/* Операция поиска */
+	// Ввести в хеш-таблицу ключ key и получить значение value
+	name := hmap[15937]
+	fmt.Println("\nДля номера 15937 найдено имя", name)
+
+	/* Операция удаления */
+	// Удалить пару (key, value) из хеш-таблицы
+	delete(hmap, 10583)
+	fmt.Println("\nПосле удаления 10583 хеш-таблица имеет вид\nКлюч -> Значение")
+	PrintMap(hmap)
+
+	/* Обход хеш-таблицы */
+	// Перебрать пары ключ-значение key->value
+	fmt.Println("\nОтдельный обход пар ключ-значение")
+	for key, value := range hmap {
+		fmt.Println(key, "->", value)
+	}
+	// Отдельно обходить ключи key
+	fmt.Println("\nОтдельный обход ключей")
+	for key := range hmap {
+		fmt.Println(key)
+	}
+	// Отдельно обходить значения value
+	fmt.Println("\nОтдельный обход значений")
+	for _, value := range hmap {
+		fmt.Println(value)
+	}
+}
+
+func TestSimpleHash(t *testing.T) {
+	var hash int
+
+	key := "Hello Algo"
+
+	hash = addHash(key)
+	fmt.Println("Хеш-сумма сложением = " + strconv.Itoa(hash))
+
+	hash = mulHash(key)
+	fmt.Println("Хеш-сумма умножением = " + strconv.Itoa(hash))
+
+	hash = xorHash(key)
+	fmt.Println("Хеш-сумма XOR = " + strconv.Itoa(hash))
+
+	hash = rotHash(key)
+	fmt.Println("Хеш-сумма с циклическим сдвигом = " + strconv.Itoa(hash))
+}

ru/codes/go/chapter_hashing/simple_hash.go

@@ -0,0 +1,55 @@
+// File: simple_hash.go
+// Created Time: 2023-06-23
+// Author: Reanon (793584285@qq.com)
+
+package chapter_hashing
+
+import "fmt"
+
+/* Аддитивное хеширование */
+func addHash(key string) int {
+	var hash int64
+	var modulus int64
+
+	modulus = 1000000007
+	for _, b := range []byte(key) {
+		hash = (hash + int64(b)) % modulus
+	}
+	return int(hash)
+}
+
+/* Мультипликативное хеширование */
+func mulHash(key string) int {
+	var hash int64
+	var modulus int64
+
+	modulus = 1000000007
+	for _, b := range []byte(key) {
+		hash = (31*hash + int64(b)) % modulus
+	}
+	return int(hash)
+}
+
+/* XOR-хеширование */
+func xorHash(key string) int {
+	hash := 0
+	modulus := 1000000007
+	for _, b := range []byte(key) {
+		fmt.Println(int(b))
+		hash ^= int(b)
+		hash = (31*hash + int(b)) % modulus
+	}
+	return hash & modulus
+}
+
+/* Хеширование с циклическим сдвигом */
+func rotHash(key string) int {
+	var hash int64
+	var modulus int64
+
+	modulus = 1000000007
+	for _, b := range []byte(key) {
+		hash = ((hash << 4) ^ (hash >> 28) ^ int64(b)) % modulus
+	}
+	return int(hash)
+}

ru/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]
+}

ru/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)
+}

ru/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-- {
+		// Выполнить heapify для всех узлов, кроме листовых
+		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)
+		// Завершить heapify, когда «корневой узел уже пройден» или «узел не требует исправления»
+		if p < 0 || h.data[i].(int) <= h.data[p].(int) {
+			break
+		}
+		// Поменять два узла местами
+		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
+		}
+		// Поменять два узла местами
+		h.swap(i, max)
+		// Циклическое просеивание вниз
+		i = max
+	}
+}
+
+/* Вывести кучу (двоичное дерево) */
+func (h *maxHeap) print() {
+	PrintHeap(h.data)
+}

ru/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
+}

ru/codes/go/chapter_searching/binary_search.go

@@ -0,0 +1,43 @@
+// File: binary_search.go
+// Created Time: 2022-12-05
+// Author: Slone123c (274325721@qq.com)
+
+package chapter_searching
+
+/* Бинарный поиск (двусторонне замкнутый интервал) */
+func binarySearch(nums []int, target int) int {
+	// Инициализировать двусторонне замкнутый интервал [0, n-1], то есть i и j указывают на первый и последний элементы массива соответственно
+	i, j := 0, len(nums)-1
+	// Цикл завершается, когда диапазон поиска пуст (при i > j диапазон пуст)
+	for i <= j {
+		m := i + (j-i)/2      // Вычислить индекс середины m
+		if nums[m] < target { // Это означает, что target находится в интервале [m+1, j]
+			i = m + 1
+		} else if nums[m] > target { // Это означает, что target находится в интервале [i, m-1]
+			j = m - 1
+		} else { // Целевой элемент найден, вернуть его индекс
+			return m
+		}
+	}
+	// Целевой элемент не найден, вернуть -1
+	return -1
+}
+
+/* Бинарный поиск (лево замкнутый, право открытый интервал) */
+func binarySearchLCRO(nums []int, target int) int {
+	// Инициализировать лево замкнутый, право открытый интервал [0, n), то есть i и j указывают на первый элемент массива и позицию сразу за последним элементом соответственно
+	i, j := 0, len(nums)
+	// Цикл завершается, когда диапазон поиска пуст (при i = j диапазон пуст)
+	for i < j {
+		m := i + (j-i)/2      // Вычислить индекс середины m
+		if nums[m] < target { // Это означает, что target находится в интервале [m+1, j)
+			i = m + 1
+		} else if nums[m] > target { // Это означает, что target находится в интервале [i, m)
+			j = m
+		} else { // Целевой элемент найден, вернуть его индекс
+			return m
+		}
+	}
+	// Целевой элемент не найден, вернуть -1
+	return -1
+}

ru/codes/go/chapter_searching/binary_search_edge.go

@@ -0,0 +1,31 @@
+// File: binary_search_edge.go
+// Created Time: 2023-08-23
+// Author: Reanon (793584285@qq.com)
+
+package chapter_searching
+
+/* Бинарный поиск самого левого target */
+func binarySearchLeftEdge(nums []int, target int) int {
+	// Эквивалентно поиску точки вставки target
+	i := binarySearchInsertion(nums, target)
+	// target не найден, вернуть -1
+	if i == len(nums) || nums[i] != target {
+		return -1
+	}
+	// Найти target и вернуть индекс i
+	return i
+}
+
+/* Бинарный поиск самого правого target */
+func binarySearchRightEdge(nums []int, target int) int {
+	// Преобразовать задачу в поиск самого левого target + 1
+	i := binarySearchInsertion(nums, target+1)
+	// j указывает на самый правый target, а i — на первый элемент больше target
+	j := i - 1
+	// target не найден, вернуть -1
+	if j == -1 || nums[j] != target {
+		return -1
+	}
+	// Найти target и вернуть индекс j
+	return j
+}

ru/codes/go/chapter_searching/binary_search_insertion.go

@@ -0,0 +1,49 @@
+// File: binary_search_insertion.go
+// Created Time: 2023-08-23
+// Author: Reanon (793584285@qq.com)
+
+package chapter_searching
+
+/* Бинарный поиск точки вставки (без повторяющихся элементов) */
+func binarySearchInsertionSimple(nums []int, target int) int {
+	// Инициализировать двусторонне замкнутый интервал [0, n-1]
+	i, j := 0, len(nums)-1
+	for i <= j {
+		// Вычислить индекс середины m
+		m := i + (j-i)/2
+		if nums[m] < target {
+			// target находится в интервале [m+1, j]
+			i = m + 1
+		} else if nums[m] > target {
+			// target находится в интервале [i, m-1]
+			j = m - 1
+		} else {
+			// Найти target и вернуть точку вставки m
+			return m
+		}
+	}
+	// target не найден, вернуть точку вставки i
+	return i
+}
+
+/* Бинарный поиск точки вставки (с повторяющимися элементами) */
+func binarySearchInsertion(nums []int, target int) int {
+	// Инициализировать двусторонне замкнутый интервал [0, n-1]
+	i, j := 0, len(nums)-1
+	for i <= j {
+		// Вычислить индекс середины m
+		m := i + (j-i)/2
+		if nums[m] < target {
+			// target находится в интервале [m+1, j]
+			i = m + 1
+		} else if nums[m] > target {
+			// target находится в интервале [i, m-1]
+			j = m - 1
+		} else {
+			// Первый элемент меньше target находится в интервале [i, m-1]
+			j = m - 1
+		}
+	}
+	// Вернуть точку вставки i
+	return i
+}

ru/codes/go/chapter_searching/binary_search_test.go

@@ -0,0 +1,61 @@
+// File: binary_search_test.go
+// Created Time: 2022-12-05
+// Author: Slone123c (274325721@qq.com)
+
+package chapter_searching
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestBinarySearch(t *testing.T) {
+	var (
+		target   = 6
+		nums     = []int{1, 3, 6, 8, 12, 15, 23, 26, 31, 35}
+		expected = 2
+	)
+	// Выполнить бинарный поиск в массиве
+	actual := binarySearch(nums, target)
+	fmt.Println("Индекс целевого элемента 6 =", actual)
+	if actual != expected {
+		t.Errorf("Индекс целевого элемента 6 = %d, должно быть %d", actual, expected)
+	}
+}
+
+func TestBinarySearchEdge(t *testing.T) {
+	// Массив с повторяющимися элементами
+	nums := []int{1, 3, 6, 8, 12, 15, 23, 26, 31, 35}
+	fmt.Println("\nМассив nums =", nums)
+
+	// Бинарный поиск левой и правой границы
+	for _, target := range []int{6, 7} {
+		index := binarySearchLeftEdge(nums, target)
+		fmt.Println("Индекс самого левого элемента", target, "равен", index)
+
+		index = binarySearchRightEdge(nums, target)
+		fmt.Println("Индекс самого правого элемента", target, "равен", index)
+	}
+}
+
+func TestBinarySearchInsertion(t *testing.T) {
+	// Массив без повторяющихся элементов
+	nums := []int{1, 3, 6, 8, 12, 15, 23, 26, 31, 35}
+	fmt.Println("Массив nums =", nums)
+
+	// Бинарный поиск точки вставки
+	for _, target := range []int{6, 9} {
+		index := binarySearchInsertionSimple(nums, target)
+		fmt.Println("Индекс позиции вставки элемента", target, "равен", index)
+	}
+
+	// Массив с повторяющимися элементами
+	nums = []int{1, 3, 6, 6, 6, 6, 6, 10, 12, 15}
+	fmt.Println("\nМассив nums =", nums)
+
+	// Бинарный поиск точки вставки
+	for _, target := range []int{2, 6, 20} {
+		index := binarySearchInsertion(nums, target)
+		fmt.Println("Индекс позиции вставки элемента", target, "равен", index)
+	}
+}

ru/codes/go/chapter_searching/hashing_search.go

@@ -0,0 +1,29 @@
+// File: hashing_search.go
+// Created Time: 2022-12-12
+// Author: Slone123c (274325721@qq.com)
+
+package chapter_searching
+
+import . "github.com/krahets/hello-algo/pkg"
+
+/* Хеш-поиск (массив) */
+func hashingSearchArray(m map[int]int, target int) int {
+	// key хеш-таблицы: целевой элемент, value: индекс
+	// Если такого key нет в хеш-таблице, вернуть -1
+	if index, ok := m[target]; ok {
+		return index
+	} else {
+		return -1
+	}
+}
+
+/* Хеш-поиск (связный список) */
+func hashingSearchLinkedList(m map[int]*ListNode, target int) *ListNode {
+	// key хеш-таблицы: значение целевого узла, value: объект узла
+	// Если такого key нет в хеш-таблице, вернуть nil
+	if node, ok := m[target]; ok {
+		return node
+	} else {
+		return nil
+	}
+}

ru/codes/go/chapter_searching/hashing_search_test.go

@@ -0,0 +1,36 @@
+// File: hashing_search_test.go
+// Created Time: 2022-12-12
+// Author: Slone123c (274325721@qq.com)
+
+package chapter_searching
+
+import (
+	"fmt"
+	"testing"
+
+	. "github.com/krahets/hello-algo/pkg"
+)
+
+func TestHashingSearch(t *testing.T) {
+	target := 3
+	/* Хеш-поиск (массив) */
+	nums := []int{1, 5, 3, 2, 4, 7, 5, 9, 10, 8}
+	// Инициализация хеш-таблицы
+	m := make(map[int]int)
+	for i := 0; i < len(nums); i++ {
+		m[nums[i]] = i
+	}
+	index := hashingSearchArray(m, target)
+	fmt.Println("Индекс целевого элемента 3 = ", index)
+
+	/* Хеш-поиск (связный список) */
+	head := ArrayToLinkedList(nums)
+	// Инициализация хеш-таблицы
+	m1 := make(map[int]*ListNode)
+	for head != nil {
+		m1[head.Val] = head
+		head = head.Next
+	}
+	node := hashingSearchLinkedList(m1, target)
+	fmt.Println("Объект узла со значением 3 =", node)
+}

ru/codes/go/chapter_searching/linear_search.go

@@ -0,0 +1,36 @@
+// File: linear_search.go
+// Created Time: 2022-11-25
+// Author: Reanon (793584285@qq.com)
+
+package chapter_searching
+
+import (
+	. "github.com/krahets/hello-algo/pkg"
+)
+
+/* Линейный поиск (массив) */
+func linearSearchArray(nums []int, target int) int {
+	// Обход массива
+	for i := 0; i < len(nums); i++ {
+		// Целевой элемент найден, вернуть его индекс
+		if nums[i] == target {
+			return i
+		}
+	}
+	// Целевой элемент не найден, вернуть -1
+	return -1
+}
+
+/* Линейный поиск (связный список) */
+func linearSearchLinkedList(node *ListNode, target int) *ListNode {
+	// Обойти связный список
+	for node != nil {
+		// Найти целевой узел и вернуть его
+		if node.Val == target {
+			return node
+		}
+		node = node.Next
+	}
+	// Целевой элемент не найден, вернуть nil
+	return nil
+}

ru/codes/go/chapter_searching/linear_search_test.go

@@ -0,0 +1,26 @@
+// File: linear_search_test.go
+// Created Time: 2022-11-25
+// Author: Reanon (793584285@qq.com)
+
+package chapter_searching
+
+import (
+	"fmt"
+	"testing"
+
+	. "github.com/krahets/hello-algo/pkg"
+)
+
+func TestLinearSearch(t *testing.T) {
+	target := 3
+	nums := []int{1, 5, 3, 2, 4, 7, 5, 9, 10, 8}
+
+	// Выполнить линейный поиск в массиве
+	index := linearSearchArray(nums, target)
+	fmt.Println("Индекс целевого элемента 3 =", index)
+
+	// Выполнить линейный поиск в связном списке
+	head := ArrayToLinkedList(nums)
+	node := linearSearchLinkedList(head, target)
+	fmt.Println("Объект узла со значением 3 =", node)
+}

ru/codes/go/chapter_searching/two_sum.go

@@ -0,0 +1,33 @@
+// File: two_sum.go
+// Created Time: 2022-11-25
+// Author: reanon (793584285@qq.com)
+
+package chapter_searching
+
+/* Метод 1: полный перебор */
+func twoSumBruteForce(nums []int, target int) []int {
+	size := len(nums)
+	// Два вложенных цикла, временная сложность O(n^2)
+	for i := 0; i < size-1; i++ {
+		for j := i + 1; j < size; j++ {
+			if nums[i]+nums[j] == target {
+				return []int{i, j}
+			}
+		}
+	}
+	return nil
+}
+
+/* Метод 2: вспомогательная хеш-таблица */
+func twoSumHashTable(nums []int, target int) []int {
+	// Вспомогательная хеш-таблица, пространственная сложность O(n)
+	hashTable := map[int]int{}
+	// Один цикл, временная сложность O(n)
+	for idx, val := range nums {
+		if preIdx, ok := hashTable[target-val]; ok {
+			return []int{preIdx, idx}
+		}
+		hashTable[val] = idx
+	}
+	return nil
+}

ru/codes/go/chapter_searching/two_sum_test.go

@@ -0,0 +1,24 @@
+// File: two_sum_test.go
+// Created Time: 2022-11-25
+// Author: reanon (793584285@qq.com)
+
+package chapter_searching
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestTwoSum(t *testing.T) {
+	// ======= Test Case =======
+	nums := []int{2, 7, 11, 15}
+	target := 13
+
+	// ====== Основной код ======
+	// Метод 1: решение полным перебором
+	res := twoSumBruteForce(nums, target)
+	fmt.Println("Результат метода 1 res =", res)
+	// Способ 2: хеш-таблица
+	res = twoSumHashTable(nums, target)
+	fmt.Println("Результат метода 2 res =", res)
+}

ru/codes/go/chapter_sorting/bubble_sort.go

@@ -0,0 +1,38 @@
+// File: bubble_sort.go
+// Created Time: 2022-12-06
+// Author: Slone123c (274325721@qq.com)
+
+package chapter_sorting
+
+/* Пузырьковая сортировка */
+func bubbleSort(nums []int) {
+	// Внешний цикл: неотсортированный диапазон [0, i]
+	for i := len(nums) - 1; i > 0; i-- {
+		// Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец
+		for j := 0; j < i; j++ {
+			if nums[j] > nums[j+1] {
+				// Поменять местами nums[j] и nums[j + 1]
+				nums[j], nums[j+1] = nums[j+1], nums[j]
+			}
+		}
+	}
+}
+
+/* Пузырьковая сортировка (оптимизация флагом) */
+func bubbleSortWithFlag(nums []int) {
+	// Внешний цикл: неотсортированный диапазон [0, i]
+	for i := len(nums) - 1; i > 0; i-- {
+		flag := false // Инициализировать флаг
+		// Внутренний цикл: переместить максимальный элемент неотсортированного диапазона [0, i] в его правый конец
+		for j := 0; j < i; j++ {
+			if nums[j] > nums[j+1] {
+				// Поменять местами nums[j] и nums[j + 1]
+				nums[j], nums[j+1] = nums[j+1], nums[j]
+				flag = true // Записать обмен элементов
+			}
+		}
+		if flag == false { // На этой итерации «всплытия» не было ни одного обмена, сразу выйти
+			break
+		}
+	}
+}

ru/codes/go/chapter_sorting/bubble_sort_test.go

@@ -0,0 +1,20 @@
+// File: bubble_sort_test.go
+// Created Time: 2022-12-06
+// Author: Slone123c (274325721@qq.com)
+
+package chapter_sorting
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestBubbleSort(t *testing.T) {
+	nums := []int{4, 1, 3, 1, 5, 2}
+	bubbleSort(nums)
+	fmt.Println("После пузырьковой сортировки nums =", nums)
+
+	nums1 := []int{4, 1, 3, 1, 5, 2}
+	bubbleSortWithFlag(nums1)
+	fmt.Println("После пузырьковой сортировки nums1 =", nums1)
+}

ru/codes/go/chapter_sorting/bucket_sort.go

@@ -0,0 +1,37 @@
+// File: bucket_sort.go
+// Created Time: 2023-03-27
+// Author: Reanon (793584285@qq.com)
+
+package chapter_sorting
+
+import "sort"
+
+/* Сортировка корзинами */
+func bucketSort(nums []float64) {
+	// Инициализировать k = n/2 корзин, предполагая распределение 2 элементов в каждую корзину
+	k := len(nums) / 2
+	buckets := make([][]float64, k)
+	for i := 0; i < k; i++ {
+		buckets[i] = make([]float64, 0)
+	}
+	// 1. Распределить элементы массива по корзинам
+	for _, num := range nums {
+		// Входные данные лежат в диапазоне [0, 1); использовать num * k для отображения в диапазон индексов [0, k-1]
+		i := int(num * float64(k))
+		// Добавить num в корзину i
+		buckets[i] = append(buckets[i], num)
+	}
+	// 2. Выполнить сортировку внутри каждой корзины
+	for i := 0; i < k; i++ {
+		// Использовать встроенную функцию сортировки среза; ее также можно заменить другим алгоритмом сортировки
+		sort.Float64s(buckets[i])
+	}
+	// 3. Обойти корзины и объединить результаты
+	i := 0
+	for _, bucket := range buckets {
+		for _, num := range bucket {
+			nums[i] = num
+			i++
+		}
+	}
+}

ru/codes/go/chapter_sorting/bucket_sort_test.go

@@ -0,0 +1,17 @@
+// File: bucket_sort_test.go
+// Created Time: 2023-03-27
+// Author: Reanon (793584285@qq.com)
+
+package chapter_sorting
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestBucketSort(t *testing.T) {
+	// Пусть входные данные — числа с плавающей точкой из диапазона [0, 1)
+	nums := []float64{0.49, 0.96, 0.82, 0.09, 0.57, 0.43, 0.91, 0.75, 0.15, 0.37}
+	bucketSort(nums)
+	fmt.Println("После сортировки корзинами nums =", nums)
+}

ru/codes/go/chapter_sorting/counting_sort.go

@@ -0,0 +1,68 @@
+// File: counting_sort.go
+// Created Time: 2023-03-20
+// Author: Reanon (793584285@qq.com)
+
+package chapter_sorting
+
+type CountingSort struct{}
+
+/* Сортировка подсчетом */
+// Простая реализация, не подходит для сортировки объектов
+func countingSortNaive(nums []int) {
+	// 1. Найти максимальный элемент массива m
+	m := 0
+	for _, num := range nums {
+		if num > m {
+			m = num
+		}
+	}
+	// 2. Подсчитать число появлений каждой цифры
+	// counter[num] обозначает число появлений num
+	counter := make([]int, m+1)
+	for _, num := range nums {
+		counter[num]++
+	}
+	// 3. Обойти counter и заполнить исходный массив nums элементами
+	for i, num := 0, 0; num < m+1; num++ {
+		for j := 0; j < counter[num]; j++ {
+			nums[i] = num
+			i++
+		}
+	}
+}
+
+/* Сортировка подсчетом */
+// Полная реализация, позволяет сортировать объекты и является стабильной сортировкой
+func countingSort(nums []int) {
+	// 1. Найти максимальный элемент массива m
+	m := 0
+	for _, num := range nums {
+		if num > m {
+			m = num
+		}
+	}
+	// 2. Подсчитать число появлений каждой цифры
+	// counter[num] обозначает число появлений num
+	counter := make([]int, m+1)
+	for _, num := range nums {
+		counter[num]++
+	}
+	// 3. Вычислить префиксные суммы counter и преобразовать «число появлений» в «конечный индекс»
+	// То есть counter[num]-1 — это индекс последнего появления num в res
+	for i := 0; i < m; i++ {
+		counter[i+1] += counter[i]
+	}
+	// 4. Обойти nums в обратном порядке и поместить элементы в результирующий массив res
+	// Инициализировать массив res для хранения результата
+	n := len(nums)
+	res := make([]int, n)
+	for i := n - 1; i >= 0; i-- {
+		num := nums[i]
+		// Поместить num по соответствующему индексу
+		res[counter[num]-1] = num
+		// Уменьшить префиксную сумму на 1, чтобы получить индекс следующего размещения num
+		counter[num]--
+	}
+	// Перезаписать исходный массив nums массивом результата res
+	copy(nums, res)
+}

ru/codes/go/chapter_sorting/counting_sort_test.go

@@ -0,0 +1,20 @@
+// File: counting_sort_test.go
+// Created Time: 2023-03-20
+// Author: Reanon (793584285@qq.com)
+
+package chapter_sorting
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestCountingSort(t *testing.T) {
+	nums := []int{1, 0, 1, 2, 0, 4, 0, 2, 2, 4}
+	countingSortNaive(nums)
+	fmt.Println("После сортировки подсчетом (объекты не поддерживаются) nums =", nums)
+
+	nums1 := []int{1, 0, 1, 2, 0, 4, 0, 2, 2, 4}
+	countingSort(nums1)
+	fmt.Println("После сортировки подсчетом nums1 =", nums1)
+}

ru/codes/go/chapter_sorting/heap_sort.go

@@ -0,0 +1,44 @@
+// File: heap_sort.go
+// Created Time: 2023-05-29
+// Author: Reanon (793584285@qq.com)
+
+package chapter_sorting
+
+/* Длина кучи равна n; начиная с узла i, выполнить просеивание сверху вниз */
+func siftDown(nums *[]int, n, i int) {
+	for true {
+		// Определить узел с максимальным значением среди i, l и r и обозначить его как ma
+		l := 2*i + 1
+		r := 2*i + 2
+		ma := i
+		if l < n && (*nums)[l] > (*nums)[ma] {
+			ma = l
+		}
+		if r < n && (*nums)[r] > (*nums)[ma] {
+			ma = r
+		}
+		// Если узел i уже максимален или индексы l и r вне границ, дальнейшее просеивание не требуется, выйти
+		if ma == i {
+			break
+		}
+		// Поменять два узла местами
+		(*nums)[i], (*nums)[ma] = (*nums)[ma], (*nums)[i]
+		// Циклическое просеивание вниз
+		i = ma
+	}
+}
+
+/* Сортировка кучей */
+func heapSort(nums *[]int) {
+	// Построение кучи: выполнить heapify для всех узлов, кроме листовых
+	for i := len(*nums)/2 - 1; i >= 0; i-- {
+		siftDown(nums, len(*nums), i)
+	}
+	// Извлекать максимальный элемент из кучи в течение n-1 итераций
+	for i := len(*nums) - 1; i > 0; i-- {
+		// Поменять корневой узел с самым правым листом местами (поменять первый и последний элементы)
+		(*nums)[0], (*nums)[i] = (*nums)[i], (*nums)[0]
+		// Начиная с корневого узла, выполнить просеивание сверху вниз
+		siftDown(nums, i, 0)
+	}
+}

ru/codes/go/chapter_sorting/heap_sort_test.go

@@ -0,0 +1,16 @@
+// File: heap_sort_test.go
+// Created Time: 2023-05-29
+// Author: Reanon (793584285@qq.com)
+
+package chapter_sorting
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestHeapSort(t *testing.T) {
+	nums := []int{4, 1, 3, 1, 5, 2}
+	heapSort(&nums)
+	fmt.Println("После сортировки кучей nums =", nums)
+}

ru/codes/go/chapter_sorting/insertion_sort.go

@@ -0,0 +1,20 @@
+// File: insertion_sort.go
+// Created Time: 2022-12-12
+// Author: msk397 (machangxinq@gmail.com)
+
+package chapter_sorting
+
+/* Сортировка вставками */
+func insertionSort(nums []int) {
+	// Внешний цикл: отсортированный диапазон [0, i-1]
+	for i := 1; i < len(nums); i++ {
+		base := nums[i]
+		j := i - 1
+		// Внутренний цикл: вставить base в правильную позицию отсортированного диапазона [0, i-1]
+		for j >= 0 && nums[j] > base {
+			nums[j+1] = nums[j] // Сдвинуть nums[j] на одну позицию вправо
+			j--
+		}
+		nums[j+1] = base // Поместить base в правильную позицию
+	}
+}