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_stack_and_queue/array_deque.go

@@ -0,0 +1,121 @@
+// File: array_deque.go
+// Created Time: 2023-03-13
+// Author: Reanon (793584285@qq.com)
+
+package chapter_stack_and_queue
+
+import "fmt"
+
+/* Двусторонняя очередь на основе кольцевого массива */
+type arrayDeque struct {
+	nums        []int // Массив для хранения элементов двусторонней очереди
+	front       int   // Указатель head, указывающий на первый элемент очереди
+	queSize     int   // Длина двусторонней очереди
+	queCapacity int   // Вместимость очереди (то есть максимальное число элементов)
+}
+
+/* Инициализация очереди */
+func newArrayDeque(queCapacity int) *arrayDeque {
+	return &arrayDeque{
+		nums:        make([]int, queCapacity),
+		queCapacity: queCapacity,
+		front:       0,
+		queSize:     0,
+	}
+}
+
+/* Получение длины двусторонней очереди */
+func (q *arrayDeque) size() int {
+	return q.queSize
+}
+
+/* Проверка, пуста ли двусторонняя очередь */
+func (q *arrayDeque) isEmpty() bool {
+	return q.queSize == 0
+}
+
+/* Вычислить индекс в кольцевом массиве */
+func (q *arrayDeque) index(i int) int {
+	// С помощью операции взятия по модулю соединить начало и конец массива
+	// Когда i выходит за конец массива, он возвращается в начало
+	// Когда i выходит за начало массива, он возвращается в конец
+	return (i + q.queCapacity) % q.queCapacity
+}
+
+/* Добавление в голову очереди */
+func (q *arrayDeque) pushFirst(num int) {
+	if q.queSize == q.queCapacity {
+		fmt.Println("Двусторонняя очередь заполнена")
+		return
+	}
+	// Указатель головы сдвигается на одну позицию влево
+	// С помощью операции взятия по модулю front после выхода за начало массива возвращается в хвост
+	q.front = q.index(q.front - 1)
+	// Добавить num в голову очереди
+	q.nums[q.front] = num
+	q.queSize++
+}
+
+/* Добавление в хвост очереди */
+func (q *arrayDeque) pushLast(num int) {
+	if q.queSize == q.queCapacity {
+		fmt.Println("Двусторонняя очередь заполнена")
+		return
+	}
+	// Вычислить указатель хвоста, указывающий на индекс хвоста + 1
+	rear := q.index(q.front + q.queSize)
+	// Добавить num в хвост очереди
+	q.nums[rear] = num
+	q.queSize++
+}
+
+/* Извлечение из головы очереди */
+func (q *arrayDeque) popFirst() any {
+	num := q.peekFirst()
+	if num == nil {
+		return nil
+	}
+	// Указатель головы сдвигается на одну позицию назад
+	q.front = q.index(q.front + 1)
+	q.queSize--
+	return num
+}
+
+/* Извлечение из хвоста очереди */
+func (q *arrayDeque) popLast() any {
+	num := q.peekLast()
+	if num == nil {
+		return nil
+	}
+	q.queSize--
+	return num
+}
+
+/* Доступ к элементу в начале очереди */
+func (q *arrayDeque) peekFirst() any {
+	if q.isEmpty() {
+		return nil
+	}
+	return q.nums[q.front]
+}
+
+/* Доступ к элементу в конце очереди */
+func (q *arrayDeque) peekLast() any {
+	if q.isEmpty() {
+		return nil
+	}
+	// Вычислить индекс хвостового элемента
+	last := q.index(q.front + q.queSize - 1)
+	return q.nums[last]
+}
+
+/* Получить Slice для вывода */
+func (q *arrayDeque) toSlice() []int {
+	// Преобразовывать только элементы списка в пределах фактической длины
+	res := make([]int, q.queSize)
+	for i, j := 0, q.front; i < q.queSize; i++ {
+		res[i] = q.nums[q.index(j)]
+		j++
+	}
+	return res
+}

ru/codes/go/chapter_stack_and_queue/array_queue.go

@@ -0,0 +1,78 @@
+// File: array_queue.go
+// Created Time: 2022-11-28
+// Author: Reanon (793584285@qq.com)
+
+package chapter_stack_and_queue
+
+/* Очередь на основе кольцевого массива */
+type arrayQueue struct {
+	nums        []int // Массив для хранения элементов очереди
+	front       int   // Указатель head, указывающий на первый элемент очереди
+	queSize     int   // Длина очереди
+	queCapacity int   // Вместимость очереди (то есть максимальное число элементов)
+}
+
+/* Инициализация очереди */
+func newArrayQueue(queCapacity int) *arrayQueue {
+	return &arrayQueue{
+		nums:        make([]int, queCapacity),
+		queCapacity: queCapacity,
+		front:       0,
+		queSize:     0,
+	}
+}
+
+/* Получение длины очереди */
+func (q *arrayQueue) size() int {
+	return q.queSize
+}
+
+/* Проверка, пуста ли очередь */
+func (q *arrayQueue) isEmpty() bool {
+	return q.queSize == 0
+}
+
+/* Поместить в очередь */
+func (q *arrayQueue) push(num int) {
+	// Когда rear == queCapacity, очередь заполнена
+	if q.queSize == q.queCapacity {
+		return
+	}
+	// Вычислить указатель хвоста, указывающий на индекс хвоста + 1
+	// С помощью операции взятия по модулю вернуть rear к началу после выхода за конец массива
+	rear := (q.front + q.queSize) % q.queCapacity
+	// Добавить num в хвост очереди
+	q.nums[rear] = num
+	q.queSize++
+}
+
+/* Извлечь из очереди */
+func (q *arrayQueue) pop() any {
+	num := q.peek()
+	if num == nil {
+		return nil
+	}
+
+	// Указатель head сдвигается на одну позицию назад; если он выходит за конец, то возвращается в начало массива
+	q.front = (q.front + 1) % q.queCapacity
+	q.queSize--
+	return num
+}
+
+/* Доступ к элементу в начале очереди */
+func (q *arrayQueue) peek() any {
+	if q.isEmpty() {
+		return nil
+	}
+	return q.nums[q.front]
+}
+
+/* Получить Slice для вывода */
+func (q *arrayQueue) toSlice() []int {
+	rear := (q.front + q.queSize)
+	if rear >= q.queCapacity {
+		rear %= q.queCapacity
+		return append(q.nums[q.front:], q.nums[:rear]...)
+	}
+	return q.nums[q.front:rear]
+}

ru/codes/go/chapter_stack_and_queue/array_stack.go

@@ -0,0 +1,55 @@
+// File: array_stack.go
+// Created Time: 2022-11-26
+// Author: Reanon (793584285@qq.com)
+
+package chapter_stack_and_queue
+
+/* Стек на основе массива */
+type arrayStack struct {
+	data []int // Данные
+}
+
+/* Инициализация стека */
+func newArrayStack() *arrayStack {
+	return &arrayStack{
+		// Установить длину стека равной 0, а емкость равной 16
+		data: make([]int, 0, 16),
+	}
+}
+
+/* Длина стека */
+func (s *arrayStack) size() int {
+	return len(s.data)
+}
+
+/* Пуст ли стек */
+func (s *arrayStack) isEmpty() bool {
+	return s.size() == 0
+}
+
+/* Поместить в стек */
+func (s *arrayStack) push(v int) {
+	// Срез автоматически расширяется
+	s.data = append(s.data, v)
+}
+
+/* Извлечь из стека */
+func (s *arrayStack) pop() any {
+	val := s.peek()
+	s.data = s.data[:len(s.data)-1]
+	return val
+}
+
+/* Получить элемент на вершине стека */
+func (s *arrayStack) peek() any {
+	if s.isEmpty() {
+		return nil
+	}
+	val := s.data[len(s.data)-1]
+	return val
+}
+
+/* Получить Slice для вывода */
+func (s *arrayStack) toSlice() []int {
+	return s.data
+}

ru/codes/go/chapter_stack_and_queue/deque_test.go

@@ -0,0 +1,141 @@
+// File: deque_test.go
+// Created Time: 2022-11-29
+// Author: Reanon (793584285@qq.com)
+
+package chapter_stack_and_queue
+
+import (
+	"container/list"
+	"fmt"
+	"testing"
+
+	. "github.com/krahets/hello-algo/pkg"
+)
+
+func TestDeque(t *testing.T) {
+	/* Инициализация двусторонней очереди */
+	// В Go list используется как двусторонняя очередь
+	deque := list.New()
+
+	/* Добавление элемента в очередь */
+	deque.PushBack(2)
+	deque.PushBack(5)
+	deque.PushBack(4)
+	deque.PushFront(3)
+	deque.PushFront(1)
+	fmt.Print("Двусторонняя очередь deque = ")
+	PrintList(deque)
+
+	/* Доступ к элементу */
+	front := deque.Front()
+	fmt.Println("Первый элемент front =", front.Value)
+	rear := deque.Back()
+	fmt.Println("Последний элемент rear =", rear.Value)
+
+	/* Извлечение элемента из очереди */
+	deque.Remove(front)
+	fmt.Print("Извлеченный из головы элемент front = ", front.Value, ", deque после извлечения из головы = ")
+	PrintList(deque)
+	deque.Remove(rear)
+	fmt.Print("Извлеченный из хвоста элемент rear = ", rear.Value, ", deque после извлечения из хвоста = ")
+	PrintList(deque)
+
+	/* Получение длины двусторонней очереди */
+	size := deque.Len()
+	fmt.Println("Длина двусторонней очереди size =", size)
+
+	/* Проверка, пуста ли двусторонняя очередь */
+	isEmpty := deque.Len() == 0
+	fmt.Println("Пуста ли двусторонняя очередь =", isEmpty)
+}
+
+func TestArrayDeque(t *testing.T) {
+	/* Инициализация двусторонней очереди */
+	// В Go list используется как двусторонняя очередь
+	deque := newArrayDeque(16)
+
+	/* Добавление элемента в очередь */
+	deque.pushLast(3)
+	deque.pushLast(2)
+	deque.pushLast(5)
+	fmt.Print("Двусторонняя очередь deque = ")
+	PrintSlice(deque.toSlice())
+
+	/* Доступ к элементу */
+	peekFirst := deque.peekFirst()
+	fmt.Println("Первый элемент peekFirst =", peekFirst)
+	peekLast := deque.peekLast()
+	fmt.Println("Последний элемент peekLast =", peekLast)
+
+	/* Добавление элемента в очередь */
+	deque.pushLast(4)
+	fmt.Print("После добавления элемента 4 в хвост deque = ")
+	PrintSlice(deque.toSlice())
+	deque.pushFirst(1)
+	fmt.Print("После добавления элемента 1 в голову deque = ")
+	PrintSlice(deque.toSlice())
+
+	/* Извлечение элемента из очереди */
+	popFirst := deque.popFirst()
+	fmt.Print("Извлеченный из головы элемент popFirst = ", popFirst, ", deque после извлечения из головы = ")
+	PrintSlice(deque.toSlice())
+	popLast := deque.popLast()
+	fmt.Print("Извлеченный из хвоста элемент popLast = ", popLast, ", deque после извлечения из хвоста = ")
+	PrintSlice(deque.toSlice())
+
+	/* Получение длины двусторонней очереди */
+	size := deque.size()
+	fmt.Println("Длина двусторонней очереди size =", size)
+
+	/* Проверка, пуста ли двусторонняя очередь */
+	isEmpty := deque.isEmpty()
+	fmt.Println("Пуста ли двусторонняя очередь =", isEmpty)
+}
+
+func TestLinkedListDeque(t *testing.T) {
+	// Инициализация очереди
+	deque := newLinkedListDeque()
+
+	// Добавление элемента в очередь
+	deque.pushLast(2)
+	deque.pushLast(5)
+	deque.pushLast(4)
+	deque.pushFirst(3)
+	deque.pushFirst(1)
+	fmt.Print("Очередь deque = ")
+	PrintList(deque.toList())
+
+	// Доступ к элементу в начале очереди
+	front := deque.peekFirst()
+	fmt.Println("Первый элемент front =", front)
+	rear := deque.peekLast()
+	fmt.Println("Последний элемент rear =", rear)
+
+	// Извлечение элемента из очереди
+	popFirst := deque.popFirst()
+	fmt.Print("Извлеченный из головы элемент popFirst = ", popFirst, ", deque после извлечения из головы = ")
+	PrintList(deque.toList())
+	popLast := deque.popLast()
+	fmt.Print("Извлеченный из хвоста элемент popLast = ", popLast, ", deque после извлечения из хвоста = ")
+	PrintList(deque.toList())
+
+	// Получить длину очереди
+	size := deque.size()
+	fmt.Println("Длина очереди size =", size)
+
+	// Проверка на пустоту
+	isEmpty := deque.isEmpty()
+	fmt.Println("Пуста ли очередь =", isEmpty)
+}
+
+// BenchmarkLinkedListDeque 67.92 ns/op in Mac M1 Pro
+func BenchmarkLinkedListDeque(b *testing.B) {
+	deque := newLinkedListDeque()
+	// use b.N for looping
+	for i := 0; i < b.N; i++ {
+		deque.pushLast(777)
+	}
+	for i := 0; i < b.N; i++ {
+		deque.popFirst()
+	}
+}

ru/codes/go/chapter_stack_and_queue/linkedlist_deque.go

@@ -0,0 +1,85 @@
+// File: linkedlist_deque.go
+// Created Time: 2022-11-29
+// Author: Reanon (793584285@qq.com)
+
+package chapter_stack_and_queue
+
+import (
+	"container/list"
+)
+
+/* Двусторонняя очередь на основе двусвязного списка */
+type linkedListDeque struct {
+	// Использовать встроенный пакет list
+	data *list.List
+}
+
+/* Инициализировать двустороннюю очередь */
+func newLinkedListDeque() *linkedListDeque {
+	return &linkedListDeque{
+		data: list.New(),
+	}
+}
+
+/* Поместить элемент в голову очереди */
+func (s *linkedListDeque) pushFirst(value any) {
+	s.data.PushFront(value)
+}
+
+/* Поместить элемент в хвост очереди */
+func (s *linkedListDeque) pushLast(value any) {
+	s.data.PushBack(value)
+}
+
+/* Извлечь элемент из головы очереди */
+func (s *linkedListDeque) popFirst() any {
+	if s.isEmpty() {
+		return nil
+	}
+	e := s.data.Front()
+	s.data.Remove(e)
+	return e.Value
+}
+
+/* Извлечь элемент из хвоста очереди */
+func (s *linkedListDeque) popLast() any {
+	if s.isEmpty() {
+		return nil
+	}
+	e := s.data.Back()
+	s.data.Remove(e)
+	return e.Value
+}
+
+/* Доступ к элементу в начале очереди */
+func (s *linkedListDeque) peekFirst() any {
+	if s.isEmpty() {
+		return nil
+	}
+	e := s.data.Front()
+	return e.Value
+}
+
+/* Доступ к элементу в конце очереди */
+func (s *linkedListDeque) peekLast() any {
+	if s.isEmpty() {
+		return nil
+	}
+	e := s.data.Back()
+	return e.Value
+}
+
+/* Получение длины очереди */
+func (s *linkedListDeque) size() int {
+	return s.data.Len()
+}
+
+/* Проверка, пуста ли очередь */
+func (s *linkedListDeque) isEmpty() bool {
+	return s.data.Len() == 0
+}
+
+/* Получить List для вывода */
+func (s *linkedListDeque) toList() *list.List {
+	return s.data
+}

ru/codes/go/chapter_stack_and_queue/linkedlist_queue.go

@@ -0,0 +1,61 @@
+// File: linkedlist_queue.go
+// Created Time: 2022-11-28
+// Author: Reanon (793584285@qq.com)
+
+package chapter_stack_and_queue
+
+import (
+	"container/list"
+)
+
+/* Очередь на основе связного списка */
+type linkedListQueue struct {
+	// Использовать встроенный пакет list для реализации очереди
+	data *list.List
+}
+
+/* Инициализация очереди */
+func newLinkedListQueue() *linkedListQueue {
+	return &linkedListQueue{
+		data: list.New(),
+	}
+}
+
+/* Поместить в очередь */
+func (s *linkedListQueue) push(value any) {
+	s.data.PushBack(value)
+}
+
+/* Извлечь из очереди */
+func (s *linkedListQueue) pop() any {
+	if s.isEmpty() {
+		return nil
+	}
+	e := s.data.Front()
+	s.data.Remove(e)
+	return e.Value
+}
+
+/* Доступ к элементу в начале очереди */
+func (s *linkedListQueue) peek() any {
+	if s.isEmpty() {
+		return nil
+	}
+	e := s.data.Front()
+	return e.Value
+}
+
+/* Получение длины очереди */
+func (s *linkedListQueue) size() int {
+	return s.data.Len()
+}
+
+/* Проверка, пуста ли очередь */
+func (s *linkedListQueue) isEmpty() bool {
+	return s.data.Len() == 0
+}
+
+/* Получить List для вывода */
+func (s *linkedListQueue) toList() *list.List {
+	return s.data
+}

ru/codes/go/chapter_stack_and_queue/linkedlist_stack.go

@@ -0,0 +1,61 @@
+// File: linkedlist_stack.go
+// Created Time: 2022-11-28
+// Author: Reanon (793584285@qq.com)
+
+package chapter_stack_and_queue
+
+import (
+	"container/list"
+)
+
+/* Стек на основе связного списка */
+type linkedListStack struct {
+	// Использовать встроенный пакет list для реализации стека
+	data *list.List
+}
+
+/* Инициализация стека */
+func newLinkedListStack() *linkedListStack {
+	return &linkedListStack{
+		data: list.New(),
+	}
+}
+
+/* Поместить в стек */
+func (s *linkedListStack) push(value int) {
+	s.data.PushBack(value)
+}
+
+/* Извлечь из стека */
+func (s *linkedListStack) pop() any {
+	if s.isEmpty() {
+		return nil
+	}
+	e := s.data.Back()
+	s.data.Remove(e)
+	return e.Value
+}
+
+/* Доступ к верхнему элементу стека */
+func (s *linkedListStack) peek() any {
+	if s.isEmpty() {
+		return nil
+	}
+	e := s.data.Back()
+	return e.Value
+}
+
+/* Получение длины стека */
+func (s *linkedListStack) size() int {
+	return s.data.Len()
+}
+
+/* Проверка, пуст ли стек */
+func (s *linkedListStack) isEmpty() bool {
+	return s.data.Len() == 0
+}
+
+/* Получить List для вывода */
+func (s *linkedListStack) toList() *list.List {
+	return s.data
+}

ru/codes/go/chapter_stack_and_queue/queue_test.go

@@ -0,0 +1,146 @@
+// File: queue_test.go
+// Created Time: 2022-11-28
+// Author: Reanon (793584285@qq.com)
+
+package chapter_stack_and_queue
+
+import (
+	"container/list"
+	"fmt"
+	"testing"
+
+	. "github.com/krahets/hello-algo/pkg"
+)
+
+func TestQueue(t *testing.T) {
+	/* Инициализация очереди */
+	// В Go list используется как очередь
+	queue := list.New()
+
+	/* Добавление элемента в очередь */
+	queue.PushBack(1)
+	queue.PushBack(3)
+	queue.PushBack(2)
+	queue.PushBack(5)
+	queue.PushBack(4)
+	fmt.Print("Очередь queue = ")
+	PrintList(queue)
+
+	/* Доступ к элементу в начале очереди */
+	peek := queue.Front()
+	fmt.Println("Первый элемент peek =", peek.Value)
+
+	/* Извлечение элемента из очереди */
+	pop := queue.Front()
+	queue.Remove(pop)
+	fmt.Print("Извлеченный элемент pop = ", pop.Value, ", queue после извлечения = ")
+	PrintList(queue)
+
+	/* Получение длины очереди */
+	size := queue.Len()
+	fmt.Println("Длина очереди size =", size)
+
+	/* Проверка, пуста ли очередь */
+	isEmpty := queue.Len() == 0
+	fmt.Println("Пуста ли очередь =", isEmpty)
+}
+
+func TestArrayQueue(t *testing.T) {
+
+	// Инициализировать очередь, используя общий интерфейс очереди
+	capacity := 10
+	queue := newArrayQueue(capacity)
+	if queue.pop() != nil {
+		t.Errorf("want:%v,got:%v", nil, queue.pop())
+	}
+
+	// Добавление элемента в очередь
+	queue.push(1)
+	queue.push(3)
+	queue.push(2)
+	queue.push(5)
+	queue.push(4)
+	fmt.Print("Очередь queue = ")
+	PrintSlice(queue.toSlice())
+
+	// Доступ к элементу в начале очереди
+	peek := queue.peek()
+	fmt.Println("Первый элемент peek =", peek)
+
+	// Извлечение элемента из очереди
+	pop := queue.pop()
+	fmt.Print("Извлеченный элемент pop = ", pop, ", queue после извлечения = ")
+	PrintSlice(queue.toSlice())
+
+	// Получить длину очереди
+	size := queue.size()
+	fmt.Println("Длина очереди size =", size)
+
+	// Проверка на пустоту
+	isEmpty := queue.isEmpty()
+	fmt.Println("Пуста ли очередь =", isEmpty)
+
+	/* Проверка кольцевого массива */
+	for i := 0; i < 10; i++ {
+		queue.push(i)
+		queue.pop()
+		fmt.Print("После ", i, "-го раунда операций enqueue и dequeue queue =")
+		PrintSlice(queue.toSlice())
+	}
+}
+
+func TestLinkedListQueue(t *testing.T) {
+	// Инициализировать очередь
+	queue := newLinkedListQueue()
+
+	// Добавление элемента в очередь
+	queue.push(1)
+	queue.push(3)
+	queue.push(2)
+	queue.push(5)
+	queue.push(4)
+	fmt.Print("Очередь queue = ")
+	PrintList(queue.toList())
+
+	// Доступ к элементу в начале очереди
+	peek := queue.peek()
+	fmt.Println("Первый элемент peek =", peek)
+
+	// Извлечение элемента из очереди
+	pop := queue.pop()
+	fmt.Print("Извлеченный элемент pop = ", pop, ", queue после извлечения = ")
+	PrintList(queue.toList())
+
+	// Получить длину очереди
+	size := queue.size()
+	fmt.Println("Длина очереди size =", size)
+
+	// Проверка на пустоту
+	isEmpty := queue.isEmpty()
+	fmt.Println("Пуста ли очередь =", isEmpty)
+}
+
+// BenchmarkArrayQueue 8 ns/op in Mac M1 Pro
+func BenchmarkArrayQueue(b *testing.B) {
+	capacity := 1000
+	queue := newArrayQueue(capacity)
+	// use b.N for looping
+	for i := 0; i < b.N; i++ {
+		queue.push(777)
+	}
+	for i := 0; i < b.N; i++ {
+		queue.pop()
+	}
+}
+
+// BenchmarkLinkedQueue 62.66 ns/op in Mac M1 Pro
+func BenchmarkLinkedQueue(b *testing.B) {
+	queue := newLinkedListQueue()
+	// use b.N for looping
+	for i := 0; i < b.N; i++ {
+		queue.push(777)
+	}
+	for i := 0; i < b.N; i++ {
+		queue.pop()
+	}
+}

ru/codes/go/chapter_stack_and_queue/stack_test.go

@@ -0,0 +1,130 @@
+// File: stack_test.go
+// Created Time: 2022-11-28
+// Author: Reanon (793584285@qq.com)
+
+package chapter_stack_and_queue
+
+import (
+	"fmt"
+	"testing"
+
+	. "github.com/krahets/hello-algo/pkg"
+)
+
+func TestStack(t *testing.T) {
+	/* Инициализация стека */
+	// В Go рекомендуется использовать Slice как стек
+	var stack []int
+
+	/* Помещение элемента в стек */
+	stack = append(stack, 1)
+	stack = append(stack, 3)
+	stack = append(stack, 2)
+	stack = append(stack, 5)
+	stack = append(stack, 4)
+	fmt.Print("Стек stack = ")
+	PrintSlice(stack)
+
+	/* Доступ к верхнему элементу стека */
+	peek := stack[len(stack)-1]
+	fmt.Println("Верхний элемент peek =", peek)
+
+	/* Извлечение элемента из стека */
+	pop := stack[len(stack)-1]
+	stack = stack[:len(stack)-1]
+	fmt.Print("Извлеченный элемент pop = ", pop, ", stack после извлечения = ")
+	PrintSlice(stack)
+
+	/* Получение длины стека */
+	size := len(stack)
+	fmt.Println("Длина стека size =", size)
+
+	/* Проверка на пустоту */
+	isEmpty := len(stack) == 0
+	fmt.Println("Пуст ли стек =", isEmpty)
+}
+
+func TestArrayStack(t *testing.T) {
+	// Инициализировать стек, используя интерфейс
+	stack := newArrayStack()
+
+	// Помещение элемента в стек
+	stack.push(1)
+	stack.push(3)
+	stack.push(2)
+	stack.push(5)
+	stack.push(4)
+	fmt.Print("Стек stack = ")
+	PrintSlice(stack.toSlice())
+
+	// Доступ к верхнему элементу стека
+	peek := stack.peek()
+	fmt.Println("Верхний элемент peek =", peek)
+
+	// Извлечение элемента из стека
+	pop := stack.pop()
+	fmt.Print("Извлеченный элемент pop = ", pop, ", stack после извлечения = ")
+	PrintSlice(stack.toSlice())
+
+	// Получение длины стека
+	size := stack.size()
+	fmt.Println("Длина стека size =", size)
+
+	// Проверка на пустоту
+	isEmpty := stack.isEmpty()
+	fmt.Println("Пуст ли стек =", isEmpty)
+}
+
+func TestLinkedListStack(t *testing.T) {
+	// Инициализация стека
+	stack := newLinkedListStack()
+	// Помещение элемента в стек
+	stack.push(1)
+	stack.push(3)
+	stack.push(2)
+	stack.push(5)
+	stack.push(4)
+	fmt.Print("Стек stack = ")
+	PrintList(stack.toList())
+
+	// Доступ к верхнему элементу стека
+	peek := stack.peek()
+	fmt.Println("Верхний элемент peek =", peek)
+
+	// Извлечение элемента из стека
+	pop := stack.pop()
+	fmt.Print("Извлеченный элемент pop = ", pop, ", stack после извлечения = ")
+	PrintList(stack.toList())
+
+	// Получение длины стека
+	size := stack.size()
+	fmt.Println("Длина стека size =", size)
+
+	// Проверка на пустоту
+	isEmpty := stack.isEmpty()
+	fmt.Println("Пуст ли стек =", isEmpty)
+}
+
+// BenchmarkArrayStack 8 ns/op in Mac M1 Pro
+func BenchmarkArrayStack(b *testing.B) {
+	stack := newArrayStack()
+	// use b.N for looping
+	for i := 0; i < b.N; i++ {
+		stack.push(777)
+	}
+	for i := 0; i < b.N; i++ {
+		stack.pop()
+	}
+}
+
+// BenchmarkLinkedListStack 65.02 ns/op in Mac M1 Pro
+func BenchmarkLinkedListStack(b *testing.B) {
+	stack := newLinkedListStack()
+	// use b.N for looping
+	for i := 0; i < b.N; i++ {
+		stack.push(777)
+	}
+	for i := 0; i < b.N; i++ {
+		stack.pop()
+	}
+}