Переделай программу так. что бы она выводила текст на русском языке:
#include <iostream>
#include <fstream>
#include <vector>
#include <queue>
#include <stack>
#include <algorithm>

struct Node {
    int key;
    Node* left;
    Node* right;

    Node(int k) : key(k), left(nullptr), right(nullptr) {}
};

// Вспомогательная функция для создания дерева по вектору ключей
Node* build_tree(std::vector<int> keys, int start, int end) {
    if (start > end) {
        return nullptr;
    }
    int mid = (start + end) / 2;
    Node* root = new Node(keys[mid]);
    root->left = build_tree(keys, start, mid-1);
    root->right = build_tree(keys, mid+1, end);
    return root;
}

// Функция для вывода всех элементов на определенном уровне дерева
void print_level(Node* root, int level) {
    if (root == nullptr) {
        return;
    }
    if (level == 0) {
        std::cout << root->key << " ";
    } else {
        print_level(root->left, level-1);
        print_level(root->right, level-1);
    }
}

// Функция для поиска наиболее надежного пути между двумя вершинами в ориентированном графе,
// заданном списками смежности и матрицей надежностей ребер
void find_most_reliable_path(std::vector<std::vector<int>>& adj_list, std::vector<std::vector<double>>& edge_reliability,
                             int start, int end) {
    int n = adj_list.size(); // количество вершин в графе
    std::vector<double> dist(n, 0); // массив для хранения наиболее надежных путей до каждой вершины
    std::vector<int> prev(n, -1); // массив для хранения предыдущих вершин на наиболее надежном пути до каждой вершины

    // Инициализация начальных значений
    dist[start] = 1;
    std::queue<int> q;
    q.push(start);

    // Обход графа в ширину с вычислением наиболее надежных путей
    while (!q.empty()) {
        int u = q.front();
        q.pop();
        for (int v : adj_list[u]) {
            double new_dist = dist[u] * edge_reliability[u][v];
            if (new_dist > dist[v]) {
                dist[v] = new_dist;
                prev[v] = u;
                q.push(v);
            }
        }
    }

    // Вывод результата
    std::stack<int> path;
    int current = end;
    while (current != -1) {
        path.push(current);
        current = prev[current];
    }
    std::cout << "Most reliable path from " << start << " to " << end << ": ";
    while (!path.empty()) {
        std::cout << path.top() << " ";
        path.pop();
    }
    std::cout << "(reliability: " << dist[end] << ")" << std::endl;
}

// Функция для сортировки Шелла
void shell_sort(std::vector<int>& arr) {
    int n = arr.size();
    for (int gap = n/2; gap > 0; gap /= 2) {
        for (int i = gap; i < n; i++) {
            int temp = arr[i];
            int j;
            for (j = i; j >= gap && arr[j-gap] > temp; j -= gap) {
                arr[j] = arr[j-gap];
            }
            arr[j] = temp;
        }
    }
}

// Функция для отображения меню и вызова соответствующих функций
void show_menu() {
    std::vector<int> tree_keys;
    Node* root = nullptr;
    std::vector<std::vector<int>> adj_list;
    std::vector<std::vector<double>> edge_reliability;
    int n_vertices = 0;

    while (true) {
        std::cout << "Choose an option:" << std::endl;
        std::cout << "1. Input binary tree" << std::endl;
        std::cout << "2. Print elements at a certain level of the tree" << std::endl;
        std::cout << "3. Find most reliable path in a graph" << std::endl;
        std::cout << "4. Perform shell sort on a list of integers" << std::endl;
        std::cout << "5. Exit" << std::endl;

        int choice;
        std::cin >> choice;

        switch (choice) {
            case 1: {
                // Ввод дерева
                std::cout << "Enter space-separated integers to put in the binary tree:" << std::endl;
                int key;
                while (std::cin >> key) {
                    tree_keys.push_back(key);
                }
                root = build_tree(tree_keys, 0, tree_keys.size()-1);
                break;
            }
            case 2: {
                // Вывод элементов на определенном уровне дерева
                std::cout << "Enter level to print:" << std::endl;
                int level;
                std::cin >> level;
                std::cout << "Elements at level " << level << ": ";
                print_level(root, level);
                std::cout << std::endl;
                break;
            }
            case 3: {
                // Ввод графа и матрицы надежностей, и нахождение наиболее надежного пути между двумя вершинами
                std::cout << "Enter number of vertices in graph:" << std::endl;
                std::cin >> n_vertices;

                // Инициализация списков смежности и матрицы надежностей
                adj_list.resize(n_vertices);
                edge_reliability.resize(n_vertices, std::vector<double>(n_vertices, 0));

                // Ввод списков смежности и матрицы надежностей
                std::cout << "Enter space-separated pairs of vertices that have an edge between them," << std::endl;
                std::cout << "followed by the reliability of that edge (separated by a comma):" << std::endl;
                int u, v;
                double r;
                while (std::cin >> u >> v >> r) {
                    adj_list[u].push_back(v);
                    edge_reliability[u][v] = r;
                }

                // Ввод вершин между которыми нужно найти наиболее надежный путь
                int start, end;
                std::cout << "Enter start and end vertices (separated by a space):" << std::endl;
                std::cin >> start >> end;

                // Нахождение наиболее надежного пути и вывод результата
                find_most_reliable_path(adj_list, edge_reliability, start, end);

                // Очистка списков смежности и матрицы надежностей
                adj_list.clear();
                edge_reliability.clear();
                break;
            }
            case 4: {
                // Сортировка Шелла списка целых чисел
                std::cout << "Enter space-separated integers to sort using shell sort:" << std::endl;
                std::vector<int> arr;
                int x;
                while (std::cin >> x) {
                    arr.push_back(x);
                }
                shell_sort(arr);
                std::cout << "Sorted array: ";
                for (int x : arr) {
                    std::cout << x << " ";
                }
                std::cout << std::endl;
                break;
            }
            case 5: {
                // Выход из программы
                return;
            }
            default: {
                std::cout << "Invalid choice. Try again." << std::endl;
                break;
            }
        }
    }
}

int main() {
    show_menu();
    return 0;
}