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/cpp/chapter_stack_and_queue/CMakeLists.txt

@@ -0,0 +1,9 @@
+add_executable(array_deque array_deque.cpp)
+add_executable(array_queue array_queue.cpp)
+add_executable(array_stack array_stack.cpp)
+add_executable(deque deque.cpp)
+add_executable(linkedlist_deque linkedlist_deque.cpp)
+add_executable(linkedlist_queue linkedlist_queue.cpp)
+add_executable(linkedlist_stack linkedlist_stack.cpp)
+add_executable(queue queue.cpp)
+add_executable(stack stack.cpp)

ru/codes/cpp/chapter_stack_and_queue/array_deque.cpp

@@ -0,0 +1,156 @@
+/**
+ * File: array_deque.cpp
+ * Created Time: 2023-03-02
+ * Author: krahets (krahets@163.com)
+ */
+
+#include "../utils/common.hpp"
+
+/* Двусторонняя очередь на основе кольцевого массива */
+class ArrayDeque {
+  private:
+    vector<int> nums; // Массив для хранения элементов двусторонней очереди
+    int front;        // Указатель head, указывающий на первый элемент очереди
+    int queSize;      // Длина двусторонней очереди
+
+  public:
+    /* Конструктор */
+    ArrayDeque(int capacity) {
+        nums.resize(capacity);
+        front = queSize = 0;
+    }
+
+    /* Получить вместимость двусторонней очереди */
+    int capacity() {
+        return nums.size();
+    }
+
+    /* Получение длины двусторонней очереди */
+    int size() {
+        return queSize;
+    }
+
+    /* Проверка, пуста ли двусторонняя очередь */
+    bool isEmpty() {
+        return queSize == 0;
+    }
+
+    /* Вычислить индекс в кольцевом массиве */
+    int index(int i) {
+        // С помощью операции взятия по модулю соединить начало и конец массива
+        // Когда i выходит за конец массива, он возвращается в начало
+        // Когда i выходит за начало массива, он возвращается в конец
+        return (i + capacity()) % capacity();
+    }
+
+    /* Добавление в голову очереди */
+    void pushFirst(int num) {
+        if (queSize == capacity()) {
+            cout << "Двусторонняя очередь заполнена" << endl;
+            return;
+        }
+        // Указатель головы сдвигается на одну позицию влево
+        // С помощью операции взятия по модулю front после выхода за начало массива возвращается в хвост
+        front = index(front - 1);
+        // Добавить num в голову очереди
+        nums[front] = num;
+        queSize++;
+    }
+
+    /* Добавление в хвост очереди */
+    void pushLast(int num) {
+        if (queSize == capacity()) {
+            cout << "Двусторонняя очередь заполнена" << endl;
+            return;
+        }
+        // Вычислить указатель хвоста, указывающий на индекс хвоста + 1
+        int rear = index(front + queSize);
+        // Добавить num в хвост очереди
+        nums[rear] = num;
+        queSize++;
+    }
+
+    /* Извлечение из головы очереди */
+    int popFirst() {
+        int num = peekFirst();
+        // Указатель головы сдвигается на одну позицию назад
+        front = index(front + 1);
+        queSize--;
+        return num;
+    }
+
+    /* Извлечение из хвоста очереди */
+    int popLast() {
+        int num = peekLast();
+        queSize--;
+        return num;
+    }
+
+    /* Доступ к элементу в начале очереди */
+    int peekFirst() {
+        if (isEmpty())
+            throw out_of_range("двусторонняя очередь пуста");
+        return nums[front];
+    }
+
+    /* Доступ к элементу в конце очереди */
+    int peekLast() {
+        if (isEmpty())
+            throw out_of_range("двусторонняя очередь пуста");
+        // Вычислить индекс хвостового элемента
+        int last = index(front + queSize - 1);
+        return nums[last];
+    }
+
+    /* Вернуть массив для вывода */
+    vector<int> toVector() {
+        // Преобразовывать только элементы списка в пределах фактической длины
+        vector<int> res(queSize);
+        for (int i = 0, j = front; i < queSize; i++, j++) {
+            res[i] = nums[index(j)];
+        }
+        return res;
+    }
+};
+
+/* Driver Code */
+int main() {
+    /* Инициализация двусторонней очереди */
+    ArrayDeque *deque = new ArrayDeque(10);
+    deque->pushLast(3);
+    deque->pushLast(2);
+    deque->pushLast(5);
+    cout << "Двусторонняя очередь deque = ";
+    printVector(deque->toVector());
+
+    /* Доступ к элементу */
+    int peekFirst = deque->peekFirst();
+    cout << "Первый элемент peekFirst = " << peekFirst << endl;
+    int peekLast = deque->peekLast();
+    cout << "Последний элемент peekLast = " << peekLast << endl;
+
+    /* Добавление элемента в очередь */
+    deque->pushLast(4);
+    cout << "После добавления элемента 4 в хвост deque = ";
+    printVector(deque->toVector());
+    deque->pushFirst(1);
+    cout << "После добавления элемента 1 в голову deque = ";
+    printVector(deque->toVector());
+
+    /* Извлечение элемента из очереди */
+    int popLast = deque->popLast();
+    cout << "Извлеченный из хвоста элемент = " << popLast << ", deque после извлечения из хвоста = ";
+    printVector(deque->toVector());
+    int popFirst = deque->popFirst();
+    cout << "Извлеченный из головы элемент = " << popFirst << ", deque после извлечения из головы = ";
+    printVector(deque->toVector());
+
+    /* Получение длины двусторонней очереди */
+    int size = deque->size();
+    cout << "Длина двусторонней очереди size = " << size << endl;
+
+    /* Проверка, пуста ли двусторонняя очередь */
+    bool isEmpty = deque->isEmpty();
+    cout << "Пуста ли двусторонняя очередь = " << boolalpha << isEmpty << endl;
+    return 0;
+}

ru/codes/cpp/chapter_stack_and_queue/array_queue.cpp

@@ -0,0 +1,129 @@
+/**
+ * File: array_queue.cpp
+ * Created Time: 2022-11-25
+ * Author: krahets (krahets@163.com)
+ */
+
+#include "../utils/common.hpp"
+
+/* Очередь на основе кольцевого массива */
+class ArrayQueue {
+  private:
+    int *nums;       // Массив для хранения элементов очереди
+    int front;       // Указатель head, указывающий на первый элемент очереди
+    int queSize;     // Длина очереди
+    int queCapacity; // Вместимость очереди
+
+  public:
+    ArrayQueue(int capacity) {
+        // Инициализация массива
+        nums = new int[capacity];
+        queCapacity = capacity;
+        front = queSize = 0;
+    }
+
+    ~ArrayQueue() {
+        delete[] nums;
+    }
+
+    /* Получить вместимость очереди */
+    int capacity() {
+        return queCapacity;
+    }
+
+    /* Получение длины очереди */
+    int size() {
+        return queSize;
+    }
+
+    /* Проверка, пуста ли очередь */
+    bool isEmpty() {
+        return size() == 0;
+    }
+
+    /* Поместить в очередь */
+    void push(int num) {
+        if (queSize == queCapacity) {
+            cout << "Очередь заполнена" << endl;
+            return;
+        }
+        // Вычислить указатель хвоста, указывающий на индекс хвоста + 1
+        // С помощью операции взятия по модулю вернуть rear к началу после выхода за конец массива
+        int rear = (front + queSize) % queCapacity;
+        // Добавить num в хвост очереди
+        nums[rear] = num;
+        queSize++;
+    }
+
+    /* Извлечь из очереди */
+    int pop() {
+        int num = peek();
+        // Указатель head сдвигается на одну позицию назад; если он выходит за конец, то возвращается в начало массива
+        front = (front + 1) % queCapacity;
+        queSize--;
+        return num;
+    }
+
+    /* Доступ к элементу в начале очереди */
+    int peek() {
+        if (isEmpty())
+            throw out_of_range("очередь пуста");
+        return nums[front];
+    }
+
+    /* Преобразовать массив в Vector и вернуть */
+    vector<int> toVector() {
+        // Преобразовывать только элементы списка в пределах фактической длины
+        vector<int> arr(queSize);
+        for (int i = 0, j = front; i < queSize; i++, j++) {
+            arr[i] = nums[j % queCapacity];
+        }
+        return arr;
+    }
+};
+
+/* Driver Code */
+int main() {
+    /* Инициализация очереди */
+    int capacity = 10;
+    ArrayQueue *queue = new ArrayQueue(capacity);
+
+    /* Добавление элемента в очередь */
+    queue->push(1);
+    queue->push(3);
+    queue->push(2);
+    queue->push(5);
+    queue->push(4);
+    cout << "Очередь queue = ";
+    printVector(queue->toVector());
+
+    /* Доступ к элементу в начале очереди */
+    int peek = queue->peek();
+    cout << "Первый элемент peek = " << peek << endl;
+
+    /* Извлечение элемента из очереди */
+    peek = queue->pop();
+    cout << "Извлеченный элемент pop = " << peek << ", queue после извлечения = ";
+    printVector(queue->toVector());
+
+    /* Получение длины очереди */
+    int size = queue->size();
+    cout << "Длина очереди size = " << size << endl;
+
+    /* Проверка, пуста ли очередь */
+    bool empty = queue->isEmpty();
+    cout << "Пуста ли очередь = " << empty << endl;
+
+    /* Проверка кольцевого массива */
+    for (int i = 0; i < 10; i++) {
+        queue->push(i);
+        queue->pop();
+        cout << "После " << i << "-го раунда операций enqueue и dequeue queue = ";
+        printVector(queue->toVector());
+    }
+
+    // Освободить память
+    delete queue;
+
+    return 0;
+}

ru/codes/cpp/chapter_stack_and_queue/array_stack.cpp

@@ -0,0 +1,85 @@
+/**
+ * File: array_stack.cpp
+ * Created Time: 2022-11-28
+ * Author: qualifier1024 (2539244001@qq.com)
+ */
+
+#include "../utils/common.hpp"
+
+/* Стек на основе массива */
+class ArrayStack {
+  private:
+    vector<int> stack;
+
+  public:
+    /* Получение длины стека */
+    int size() {
+        return stack.size();
+    }
+
+    /* Проверка, пуст ли стек */
+    bool isEmpty() {
+        return stack.size() == 0;
+    }
+
+    /* Поместить в стек */
+    void push(int num) {
+        stack.push_back(num);
+    }
+
+    /* Извлечь из стека */
+    int pop() {
+        int num = top();
+        stack.pop_back();
+        return num;
+    }
+
+    /* Доступ к верхнему элементу стека */
+    int top() {
+        if (isEmpty())
+            throw out_of_range("стек пуст");
+        return stack.back();
+    }
+
+    /* Вернуть Vector */
+    vector<int> toVector() {
+        return stack;
+    }
+};
+
+/* Driver Code */
+int main() {
+    /* Инициализация стека */
+    ArrayStack *stack = new ArrayStack();
+
+    /* Помещение элемента в стек */
+    stack->push(1);
+    stack->push(3);
+    stack->push(2);
+    stack->push(5);
+    stack->push(4);
+    cout << "Стек stack = ";
+    printVector(stack->toVector());
+
+    /* Доступ к верхнему элементу стека */
+    int top = stack->top();
+    cout << "Верхний элемент top = " << top << endl;
+
+    /* Извлечение элемента из стека */
+    top = stack->pop();
+    cout << "Извлеченный элемент pop = " << top << ", stack после извлечения = ";
+    printVector(stack->toVector());
+
+    /* Получение длины стека */
+    int size = stack->size();
+    cout << "Длина стека size = " << size << endl;
+
+    /* Проверка на пустоту */
+    bool empty = stack->isEmpty();
+    cout << "Пуст ли стек = " << empty << endl;
+
+    // Освободить память
+    delete stack;
+
+    return 0;
+}

ru/codes/cpp/chapter_stack_and_queue/deque.cpp

@@ -0,0 +1,46 @@
+/**
+ * File: deque.cpp
+ * Created Time: 2022-11-25
+ * Author: krahets (krahets@163.com)
+ */
+
+#include "../utils/common.hpp"
+
+/* Driver Code */
+int main() {
+    /* Инициализация двусторонней очереди */
+    deque<int> deque;
+
+    /* Добавление элемента в очередь */
+    deque.push_back(2);
+    deque.push_back(5);
+    deque.push_back(4);
+    deque.push_front(3);
+    deque.push_front(1);
+    cout << "Двусторонняя очередь deque = ";
+    printDeque(deque);
+
+    /* Доступ к элементу */
+    int front = deque.front();
+    cout << "Первый элемент front = " << front << endl;
+    int back = deque.back();
+    cout << "Последний элемент back = " << back << endl;
+
+    /* Извлечение элемента из очереди */
+    deque.pop_front();
+    cout << "Извлеченный из головы элемент popFront = " << front << ", deque после извлечения из головы = ";
+    printDeque(deque);
+    deque.pop_back();
+    cout << "Извлеченный из хвоста элемент popLast = " << back << ", deque после извлечения из хвоста = ";
+    printDeque(deque);
+
+    /* Получение длины двусторонней очереди */
+    int size = deque.size();
+    cout << "Длина двусторонней очереди size = " << size << endl;
+
+    /* Проверка, пуста ли двусторонняя очередь */
+    bool empty = deque.empty();
+    cout << "Пуста ли двусторонняя очередь = " << empty << endl;
+
+    return 0;
+}

ru/codes/cpp/chapter_stack_and_queue/linkedlist_deque.cpp

@@ -0,0 +1,194 @@
+/**
+ * File: linkedlist_deque.cpp
+ * Created Time: 2023-03-02
+ * Author: krahets (krahets@163.com)
+ */
+
+#include "../utils/common.hpp"
+
+/* Узел двусвязного списка */
+struct DoublyListNode {
+    int val;              // Значение узла
+    DoublyListNode *next; // Указатель на узел-преемник
+    DoublyListNode *prev; // Указатель на узел-предшественник
+    DoublyListNode(int val) : val(val), prev(nullptr), next(nullptr) {
+    }
+};
+
+/* Двусторонняя очередь на основе двусвязного списка */
+class LinkedListDeque {
+  private:
+    DoublyListNode *front, *rear; // Головной узел front, хвостовой узел rear
+    int queSize = 0;              // Длина двусторонней очереди
+
+  public:
+    /* Конструктор */
+    LinkedListDeque() : front(nullptr), rear(nullptr) {
+    }
+
+    /* Метод-деструктор */
+    ~LinkedListDeque() {
+        // Обходить связный список, удалять узлы и освобождать память
+        DoublyListNode *pre, *cur = front;
+        while (cur != nullptr) {
+            pre = cur;
+            cur = cur->next;
+            delete pre;
+        }
+    }
+
+    /* Получение длины двусторонней очереди */
+    int size() {
+        return queSize;
+    }
+
+    /* Проверка, пуста ли двусторонняя очередь */
+    bool isEmpty() {
+        return size() == 0;
+    }
+
+    /* Операция добавления в очередь */
+    void push(int num, bool isFront) {
+        DoublyListNode *node = new DoublyListNode(num);
+        // Если связный список пуст, сделать так, чтобы и front, и rear указывали на node
+        if (isEmpty())
+            front = rear = node;
+        // Операция добавления в голову очереди
+        else if (isFront) {
+            // Добавить node в голову списка
+            front->prev = node;
+            node->next = front;
+            front = node; // Обновить головной узел
+        // Операция добавления в хвост очереди
+        } else {
+            // Добавить node в хвост списка
+            rear->next = node;
+            node->prev = rear;
+            rear = node; // Обновить хвостовой узел
+        }
+        queSize++; // Обновить длину очереди
+    }
+
+    /* Добавление в голову очереди */
+    void pushFirst(int num) {
+        push(num, true);
+    }
+
+    /* Добавление в хвост очереди */
+    void pushLast(int num) {
+        push(num, false);
+    }
+
+    /* Операция извлечения из очереди */
+    int pop(bool isFront) {
+        if (isEmpty())
+            throw out_of_range("очередь пуста");
+        int val;
+        // Операция извлечения из головы очереди
+        if (isFront) {
+            val = front->val; // Временно сохранить значение головного узла
+            // Удалить головной узел
+            DoublyListNode *fNext = front->next;
+            if (fNext != nullptr) {
+                fNext->prev = nullptr;
+                front->next = nullptr;
+            }
+            delete front;
+            front = fNext; // Обновить головной узел
+        // Операция извлечения из хвоста очереди
+        } else {
+            val = rear->val; // Временно сохранить значение хвостового узла
+            // Удалить хвостовой узел
+            DoublyListNode *rPrev = rear->prev;
+            if (rPrev != nullptr) {
+                rPrev->next = nullptr;
+                rear->prev = nullptr;
+            }
+            delete rear;
+            rear = rPrev; // Обновить хвостовой узел
+        }
+        queSize--; // Обновить длину очереди
+        return val;
+    }
+
+    /* Извлечение из головы очереди */
+    int popFirst() {
+        return pop(true);
+    }
+
+    /* Извлечение из хвоста очереди */
+    int popLast() {
+        return pop(false);
+    }
+
+    /* Доступ к элементу в начале очереди */
+    int peekFirst() {
+        if (isEmpty())
+            throw out_of_range("двусторонняя очередь пуста");
+        return front->val;
+    }
+
+    /* Доступ к элементу в конце очереди */
+    int peekLast() {
+        if (isEmpty())
+            throw out_of_range("двусторонняя очередь пуста");
+        return rear->val;
+    }
+
+    /* Вернуть массив для вывода */
+    vector<int> toVector() {
+        DoublyListNode *node = front;
+        vector<int> res(size());
+        for (int i = 0; i < res.size(); i++) {
+            res[i] = node->val;
+            node = node->next;
+        }
+        return res;
+    }
+};
+
+/* Driver Code */
+int main() {
+    /* Инициализация двусторонней очереди */
+    LinkedListDeque *deque = new LinkedListDeque();
+    deque->pushLast(3);
+    deque->pushLast(2);
+    deque->pushLast(5);
+    cout << "Двусторонняя очередь deque = ";
+    printVector(deque->toVector());
+
+    /* Доступ к элементу */
+    int peekFirst = deque->peekFirst();
+    cout << "Первый элемент peekFirst = " << peekFirst << endl;
+    int peekLast = deque->peekLast();
+    cout << "Последний элемент peekLast = " << peekLast << endl;
+
+    /* Добавление элемента в очередь */
+    deque->pushLast(4);
+    cout << "После добавления элемента 4 в хвост deque =";
+    printVector(deque->toVector());
+    deque->pushFirst(1);
+    cout << "После добавления элемента 1 в голову deque = ";
+    printVector(deque->toVector());
+
+    /* Извлечение элемента из очереди */
+    int popLast = deque->popLast();
+    cout << "Извлеченный из хвоста элемент = " << popLast << ", deque после извлечения из хвоста = ";
+    printVector(deque->toVector());
+    int popFirst = deque->popFirst();
+    cout << "Извлеченный из головы элемент = " << popFirst << ", deque после извлечения из головы = ";
+    printVector(deque->toVector());
+
+    /* Получение длины двусторонней очереди */
+    int size = deque->size();
+    cout << "Длина двусторонней очереди size = " << size << endl;
+
+    /* Проверка, пуста ли двусторонняя очередь */
+    bool isEmpty = deque->isEmpty();
+    cout << "Пуста ли двусторонняя очередь = " << boolalpha << isEmpty << endl;
+
+    // Освободить память
+    delete deque;
+
+    return 0;
+}

ru/codes/cpp/chapter_stack_and_queue/linkedlist_queue.cpp

@@ -0,0 +1,120 @@
+/**
+ * File: linkedlist_queue.cpp
+ * Created Time: 2022-11-25
+ * Author: krahets (krahets@163.com)
+ */
+
+#include "../utils/common.hpp"
+
+/* Очередь на основе связного списка */
+class LinkedListQueue {
+  private:
+    ListNode *front, *rear; // Головной узел front, хвостовой узел rear
+    int queSize;
+
+  public:
+    LinkedListQueue() {
+        front = nullptr;
+        rear = nullptr;
+        queSize = 0;
+    }
+
+    ~LinkedListQueue() {
+        // Обходить связный список, удалять узлы и освобождать память
+        freeMemoryLinkedList(front);
+    }
+
+    /* Получение длины очереди */
+    int size() {
+        return queSize;
+    }
+
+    /* Проверка, пуста ли очередь */
+    bool isEmpty() {
+        return queSize == 0;
+    }
+
+    /* Поместить в очередь */
+    void push(int num) {
+        // Добавить num после хвостового узла
+        ListNode *node = new ListNode(num);
+        // Если очередь пуста, сделать так, чтобы и head, и tail указывали на этот узел
+        if (front == nullptr) {
+            front = node;
+            rear = node;
+        }
+        // Если очередь не пуста, добавить этот узел после хвостового узла
+        else {
+            rear->next = node;
+            rear = node;
+        }
+        queSize++;
+    }
+
+    /* Извлечь из очереди */
+    int pop() {
+        int num = peek();
+        // Удалить головной узел
+        ListNode *tmp = front;
+        front = front->next;
+        // Освободить память
+        delete tmp;
+        queSize--;
+        return num;
+    }
+
+    /* Доступ к элементу в начале очереди */
+    int peek() {
+        if (size() == 0)
+            throw out_of_range("очередь пуста");
+        return front->val;
+    }
+
+    /* Преобразовать связный список в Vector и вернуть */
+    vector<int> toVector() {
+        ListNode *node = front;
+        vector<int> res(size());
+        for (int i = 0; i < res.size(); i++) {
+            res[i] = node->val;
+            node = node->next;
+        }
+        return res;
+    }
+};
+
+/* Driver Code */
+int main() {
+    /* Инициализация очереди */
+    LinkedListQueue *queue = new LinkedListQueue();
+
+    /* Добавление элемента в очередь */
+    queue->push(1);
+    queue->push(3);
+    queue->push(2);
+    queue->push(5);
+    queue->push(4);
+    cout << "Очередь queue = ";
+    printVector(queue->toVector());
+
+    /* Доступ к элементу в начале очереди */
+    int peek = queue->peek();
+    cout << "Первый элемент peek = " << peek << endl;
+
+    /* Извлечение элемента из очереди */
+    peek = queue->pop();
+    cout << "Извлеченный элемент pop = " << peek << ", queue после извлечения = ";
+    printVector(queue->toVector());
+
+    /* Получение длины очереди */
+    int size = queue->size();
+    cout << "Длина очереди size = " << size << endl;
+
+    /* Проверка, пуста ли очередь */
+    bool empty = queue->isEmpty();
+    cout << "Пуста ли очередь = " << empty << endl;
+
+    // Освободить память
+    delete queue;
+
+    return 0;
+}

ru/codes/cpp/chapter_stack_and_queue/linkedlist_stack.cpp

@@ -0,0 +1,109 @@
+/**
+ * File: linkedlist_stack.cpp
+ * Created Time: 2022-11-28
+ * Author: qualifier1024 (2539244001@qq.com)
+ */
+
+#include "../utils/common.hpp"
+
+/* Стек на основе связного списка */
+class LinkedListStack {
+  private:
+    ListNode *stackTop; // Использовать головной узел как вершину стека
+    int stkSize;        // Длина стека
+
+  public:
+    LinkedListStack() {
+        stackTop = nullptr;
+        stkSize = 0;
+    }
+
+    ~LinkedListStack() {
+        // Обходить связный список, удалять узлы и освобождать память
+        freeMemoryLinkedList(stackTop);
+    }
+
+    /* Получение длины стека */
+    int size() {
+        return stkSize;
+    }
+
+    /* Проверка, пуст ли стек */
+    bool isEmpty() {
+        return size() == 0;
+    }
+
+    /* Поместить в стек */
+    void push(int num) {
+        ListNode *node = new ListNode(num);
+        node->next = stackTop;
+        stackTop = node;
+        stkSize++;
+    }
+
+    /* Извлечь из стека */
+    int pop() {
+        int num = top();
+        ListNode *tmp = stackTop;
+        stackTop = stackTop->next;
+        // Освободить память
+        delete tmp;
+        stkSize--;
+        return num;
+    }
+
+    /* Доступ к верхнему элементу стека */
+    int top() {
+        if (isEmpty())
+            throw out_of_range("стек пуст");
+        return stackTop->val;
+    }
+
+    /* Преобразовать List в Array и вернуть */
+    vector<int> toVector() {
+        ListNode *node = stackTop;
+        vector<int> res(size());
+        for (int i = res.size() - 1; i >= 0; i--) {
+            res[i] = node->val;
+            node = node->next;
+        }
+        return res;
+    }
+};
+
+/* Driver Code */
+int main() {
+    /* Инициализация стека */
+    LinkedListStack *stack = new LinkedListStack();
+
+    /* Помещение элемента в стек */
+    stack->push(1);
+    stack->push(3);
+    stack->push(2);
+    stack->push(5);
+    stack->push(4);
+    cout << "Стек stack = ";
+    printVector(stack->toVector());
+
+    /* Доступ к верхнему элементу стека */
+    int top = stack->top();
+    cout << "Верхний элемент top = " << top << endl;
+
+    /* Извлечение элемента из стека */
+    top = stack->pop();
+    cout << "Извлеченный элемент pop = " << top << ", stack после извлечения = ";
+    printVector(stack->toVector());
+
+    /* Получение длины стека */
+    int size = stack->size();
+    cout << "Длина стека size = " << size << endl;
+
+    /* Проверка на пустоту */
+    bool empty = stack->isEmpty();
+    cout << "Пуст ли стек = " << empty << endl;
+
+    // Освободить память
+    delete stack;
+
+    return 0;
+}

ru/codes/cpp/chapter_stack_and_queue/queue.cpp

@@ -0,0 +1,41 @@
+/**
+ * File: queue.cpp
+ * Created Time: 2022-11-28
+ * Author: qualifier1024 (2539244001@qq.com)
+ */
+
+#include "../utils/common.hpp"
+
+/* Driver Code */
+int main() {
+    /* Инициализация очереди */
+    queue<int> queue;
+
+    /* Добавление элемента в очередь */
+    queue.push(1);
+    queue.push(3);
+    queue.push(2);
+    queue.push(5);
+    queue.push(4);
+    cout << "Очередь queue = ";
+    printQueue(queue);
+
+    /* Доступ к элементу в начале очереди */
+    int front = queue.front();
+    cout << "Первый элемент front = " << front << endl;
+
+    /* Извлечение элемента из очереди */
+    queue.pop();
+    cout << "Извлеченный элемент front = " << front << ", queue после извлечения = ";
+    printQueue(queue);
+
+    /* Получение длины очереди */
+    int size = queue.size();
+    cout << "Длина очереди size = " << size << endl;
+
+    /* Проверка, пуста ли очередь */
+    bool empty = queue.empty();
+    cout << "Пуста ли очередь = " << empty << endl;
+
+    return 0;
+}

ru/codes/cpp/chapter_stack_and_queue/stack.cpp

@@ -0,0 +1,41 @@
+/**
+ * File: stack.cpp
+ * Created Time: 2022-11-28
+ * Author: qualifier1024 (2539244001@qq.com)
+ */
+
+#include "../utils/common.hpp"
+
+/* Driver Code */
+int main() {
+    /* Инициализация стека */
+    stack<int> stack;
+
+    /* Помещение элемента в стек */
+    stack.push(1);
+    stack.push(3);
+    stack.push(2);
+    stack.push(5);
+    stack.push(4);
+    cout << "Стек stack = ";
+    printStack(stack);
+
+    /* Доступ к верхнему элементу стека */
+    int top = stack.top();
+    cout << "Верхний элемент top = " << top << endl;
+
+    /* Извлечение элемента из стека */
+    stack.pop(); // Без возвращаемого значения
+    cout << "Извлеченный элемент pop = " << top << ", stack после извлечения = ";
+    printStack(stack);
+
+    /* Получение длины стека */
+    int size = stack.size();
+    cout << "Длина стека size = " << size << endl;
+
+    /* Проверка на пустоту */
+    bool empty = stack.empty();
+    cout << "Пуст ли стек = " << empty << endl;
+
+    return 0;
+}