исправь ошибки в 25 и 27 строчке:#include <iostream>
#include <vector>
#include <ctime>

using namespace std;
template <class T>
void radixSort(vector<T>& a) {
    if (a.empty()) {
        return;
    }

    T maxNum = max_element(a.begin(), a.end());
    for (int exp = 1; maxNum / exp > 0; exp = 10) {
        vector<T> count(10, 0);
        vector<T> output(a.size());

        for (int i = 0; i < a.size(); i++) {
            count[(a[i] / exp) % 10]++;
        }

        for (int i = 1; i < 10; i++) {
            count[i] += count[i - 1];
        }

        for (int i = a.size() - 1; i >= 0; i-) {
            output[count[(a[i] / exp) % 10] - 1] = a[i];
            count[(a[i] / exp) % 10] -;
        }

        for (int i = 0; i < a.size(); i++) {
            a[i] = output[i];
        }
    }
}
template< class T >
void downHeap(vector<T>& a, long k, long n)
{
    T new_elem;
    long child;
    new_elem = a[k];

    while (k <= n / 2)
    {
        child = 2 * k;

        if (child < n && a[child] < a[child + 1])
            child++;
        if (new_elem >= a[child])
            break;
        a[k] = a[child];
        k = child;
    }
    a[k] = new_elem;
}

template<class T>
struct TreeNode {
    T data;
    TreeNode* left;
    TreeNode* right;

    TreeNode(T value) {
        data = value;
        left = nullptr;
        right = nullptr;
    }
};

template<class T>
void insert(TreeNode<T>*& root, T value) {
    if (root == nullptr) {
        root = new TreeNode<T>(value);
        return;
    }

    if (value < root->data) {
        insert(root->left, value);
    }
    else {
        insert(root->right, value);
    }
}

template<class T>
void inOrderTraversal(TreeNode<T>* root, vector<T>& sortedArray) {
    if (root == nullptr) {
        return;
    }

    inOrderTraversal(root->left, sortedArray);
    sortedArray.push_back(root->data);
    inOrderTraversal(root->right, sortedArray);
}

template<class T>
void binaryTreeSort(vector<T>& a) {
    TreeNode<T>* root = nullptr;

    for (const T& value : a) {
        insert(root, value);
    }

    a.clear();
    inOrderTraversal(root, a);

    for (int i = a.size() - 1; i >= 0; i--) {
        cout << " " << a[i];
    }
}


int main() {
    setlocale(LC_ALL, "Russian");
    int n;
    cout << "Введите размер массива" << endl;
    cin >> n;

    vector<int> A(n);
    vector<int> B(n);
    vector<int> C;

    for (int i = 0; i < n; i++) {
        A[i] = -10000 + rand() % 20001;
        B[i] = -10000 + rand() % 20001;
    }

    for (int i = 0; i < n; i++) {
        cout << " " << A[i];
    }

    cout << endl;

    for (int i = 0; i < n; i++) {
        cout << " " << B[i];
    }

    for (int i = 0; i < n; i++) {
        if (A[i] % 2 == 0) {
            C.push_back(A[i]);
        }
        if (B[i] % 2 != 0) {
            C.push_back(B[i]);
        }
    }

    cout << endl;

    for (int i = 0; i < C.size(); i++) {
        cout << " " << C[i];
    }

    cout << endl << "Бинарное дерево - 1" << endl;
    int flag;
    cin >> flag;
    clock_t start_time = clock();
    if (flag == 1) binaryTreeSort(C);
    if (flag == 2) radixSort(C);
    clock_t end_time = clock();
    double duration = (static_cast<double>(end_time -
        start_time)) / CLOCKS_PER_SEC;
    cout << " Time: " << duration << "sec" << endl;

    return 0;
}