Ошибка при удалении указателя

_CRT_SECURITYCRITICAL_ATTRIBUTE
void __CRTDECL operator delete(void* const block) noexcept
{
    #ifdef _DEBUG
    _free_dbg(block, _UNKNOWN_BLOCK);
    #else
    free(block);
    #endif
}

int increaseArray(List*& nList, int& amountOfLists)
{
    if (amountOfLists == 0) nList = new List[1];
    else
    {   // с помощью временного массива данные копируются из старого массива в новый увеличенный массив
        List* temp = new List[amountOfLists + 1];
        for (size_t i = 0; i < amountOfLists; i++) temp[i] = nList[i];
        delete[] nList;
        nList = temp;
    }
    return 0;
}
 
int addList(List*& nList, int& amountOfLists, List list)
{
    increaseArray(nList, amountOfLists);
    nList[amountOfLists] = list; // запись листа в массив
    amountOfLists++;
    return 0;
}

#include <iostream>
#include <string>
#include <sstream>
#include <limits>
struct Node // Структура узла
{
    int value;
    Node* next;
    Node(int val) : value(val), next(nullptr) {} // Конструктор узла
};
 
class List // Класс списка
{
private:
    Node* root;
    int count;
 
public:
    List() : root(nullptr), count(0) {} // Конструктор списка
 
    ~List() // Деструктор списка
    {
        // Пока корень не равен указателю вникуда
        // меняем нынешний корень на следующий
        // и удалем предыдущий
        while (root != nullptr) 
        {
            Node* temp = root;
            root = root->next;
            delete temp;
        }
    }
 
    int append(int val) // Добавить узел в конец списка
    {
        Node* new_node = new Node(val);
        // Если корень ещё не задан, то корень
        // становится новым узлом
        if (root == nullptr) root = new_node;
        else 
        {
            // Иначе пока следующий узел не пуст
            // меняем текущий узел на следующий
            Node* current = root;
            while (current->next) 
            {
                current = current->next;
            }
            // Доходим до последнего узла - создаём новый узел
            current->next = new_node;
        }
        count++; // Увеличиваем счётчик узлов
        return 0;
    }
    
    int insertAfter(int val, int index) // Вставить узел после указанного узла
    {
        Node* new_node = new Node(val);
        Node* current = root;
        int innerIndex = 0;
        // Пока не пройдём список проверяем значение в узле
        while (current != nullptr) 
        {
            // Если текущее значение равно нужному, то
            // устанавливается связь между новым узлом и следующим узлом
            // и устанавливается связь между текущим узлом и новым узлом,
            // увеличивается счетчик узлов count
            if (innerIndex == index) 
            {
                new_node->next = current->next;
                current->next = new_node;
                count++;
                return 0;
            }
            current = current->next;
        }
        // Если весь список был пройден, значит вставить элемент не удалось
        if (current == nullptr) throw std::out_of_range("Выход за пределы списка.");
        return 1;
    }
 
    int remove(int index) // Удаление узла
    {
        Node* current = root;
        Node* prev = nullptr;
        int innerIndex = 0;
        // Пока не пройдём список проверяем значение в узле
        while (current != nullptr) 
        {
            // Если нужное значение найдено, то проверяем является ли узел перед
            // ним первым, если да, то корнем становится следующий узел
            // иначе указатель next предыдущего узла переназначается на следующий узел
            if (innerIndex == index) 
            {
                if (prev == nullptr) root = current->next;
                else prev->next = current->next;
                count--;
                delete current;
                return 0;
            }
            prev = current;
            current = current->next;
            innerIndex++;
        }
        if (current == nullptr) throw std::out_of_range("Выход за пределы списка.");
        return 1;
    }
 
    int getCount() const // Метод получения кол-ва узлов в списке
    {
        return count;
    }
 
    bool isEmpty() const // Метод проверки списка на его пустоту
    {
        return count == 0;
    }
 
    List& operator=(const List& other) // Метод для оператора присваивания
    {
        // Если один список равен другому, то присваивание не имеет смысла
        if (this == &other) return *this;
        // Иначе удаляем уже существовавший список если он был
        while (root != nullptr) 
        {
            Node* temp = root;
            root = root->next;
            delete temp;
        }
 
        count = 0; // Сбрасываем счётчик узлов
        // Записываем в первый список всё из другого
        Node* current = other.root;
        while (current != nullptr) 
        {
            append(current->value);
            current = current->next;
        }
 
        return *this;
    }
    
    List operator+(const List& other) const // Метод для оператора склеивания двух списков
    {
        // Создаём копию текущего объекта
        List result = *this;
        // Добавляем к списку все узлы из другого списка
        Node* current = other.root;
        while (current != nullptr) 
        {
            result.append(current->value);
            current = current->next;
        }
 
        return result;
    }
 
    bool operator==(const List& other) const // Метод для оператора равенства
    {
        // Если количество узлов в первом списке не равно
        // количеству узлов второго списка, то они не равны
        if (count != other.count) return false;
 
        Node* current_a = root;
        Node* current_b = other.root;
        // Иначе сравниваем каждый узел из двух списков
        // между собой
        while (current_a != nullptr) 
        {
            if (current_a->value != current_b->value) 
            {
                return false;
            }
 
            current_a = current_a->next;
            current_b = current_b->next;
        }
 
        return true;
    }
 
    bool operator!=(const List& other) const // Метод для оператора не равенства
    {
        // Используя ранее описанный метод равенства 
        // создаём метод не равенства
        return !(*this == other);
    }
 
    friend std::ostream& operator<<(std::ostream& os, const List& list) // Метод для оператора вывода
    {
        // Устанавливается указатель на корень списка и пока
        // не конец списка в поток помещается значение узла через пробел
        Node* current = list.root;
        while (current != nullptr) 
        {
            os << current->value << " ";
            current = current->next;
        }
        return os;
    }
 
    friend std::istream& operator>>(std::istream& is, List& list) // Метод для оператора ввода
    {
        std::string line;
        std::getline(is, line); // Чтение всей строки из входного потока
 
        std::istringstream iss(line); // Создание потока для чтения отдельных значений
        int val;
        while (iss >> val)
        {
            list.append(val); // Добавление значения к списку
        }
     
        return is;
    }
};

#include "list.h"
#include <vector>
#include <limits>
#include <stdexcept>
using namespace std;
 
int printEveryList(const List* nList, const int amountOfLists)
{
    for (size_t i = 0; i < amountOfLists; i++) cout << nList[i] << endl;
    return 0;
}
 
int increaseArray(List*& nList, int& amountOfLists)
{
    if (amountOfLists == 0) nList = new List[1];
    else
    {   // с помощью временного массива данные копируются из старого массива в новый увеличенный массив
        List* temp = new List[amountOfLists + 1];
        for (size_t i = 0; i < amountOfLists; i++) temp[i] = nList[i];
        delete[] nList;
        nList = temp;
    }
    return 0;
}
 
int addList(List*& nList, int& amountOfLists, List list)
{
    increaseArray(nList, amountOfLists);
    nList[amountOfLists] = list; // запись листа в массив
    amountOfLists++;
    return 0;
}
 
int main() 
{
    int intOption, numberOfList, numberOfAnotherList, value, index;
    string strOption;
    List* nList = nullptr;
    int amountOfLists = 0;
    do
    {
        cout << "*************Список*************\n";
        cout << "Для создания нового списка введите 1\n";
        cout << "Для добавления узла в конец списка введите 2\n";
        cout << "Для вставки узла после определённого узла введите 3\n";
        cout << "Для удаления определённого узла введите 4\n";
        cout << "Для присваивания списку другого списка введите 5\n";
        cout << "Для вывода всех списков введите 6\n";
        cout << "Для выхода из данной программы введите 0\n";
 
        while (true) 
        {
            try 
            {
                cin >> intOption;
                if (cin.fail()) throw invalid_argument("Ошибка ввода данных.");
                break;
            } 
            catch (const exception& ex) 
            {
                cerr << "Произошла ошибка: " << ex.what() << endl;
                cin.clear();
                cin.ignore(numeric_limits<streamsize>::max(), '\n');
            }
        }
 
        switch (intOption)
        {
            case 1:
            {
                while (true)
                {
                    cout << "Хотите ввести его элементы?(При отказе будет создан пустой список) Y/N\n";
                    cin >> strOption;
                    if (strOption == "Y" || strOption == "y")
                    {
                        List list;
                        while (true) // Ввод номера списка для взаимодействия
                        {
                            cout << "Введите узлы: ";
                            try 
                            {
                                cin.ignore(numeric_limits<streamsize>::max(), '\n');
                                cin >> list;
                                if (cin.fail()) throw invalid_argument("Ошибка ввода данных.");
                                break;
                            } 
                            catch (const exception& ex) 
                            {
                                cerr << "Произошла ошибка: " << ex.what() << endl;
                                cin.clear();
                                cin.ignore(numeric_limits<streamsize>::max(), '\n');
                            }
                        }
                        addList(nList, amountOfLists, list);
                        break;
                    }
                    else if (strOption == "N" || strOption == "n")
                    {
                        List list;
                        addList(nList, amountOfLists, list);
                        break;
                    }
                    else cout << "Неккоректный ввод! Введите Y или N.\n";
                }
                break;
            }
            case 2:
            {
                while (true) // Ввод номера списка для взаимодействия
                {
                    cout << "Введите номер списка с которым хотите взаимодействовать: ";
                    try 
                    {
                        cin >> numberOfList;
                        if (cin.fail()) throw invalid_argument("Ошибка ввода данных.");
                        else if(numberOfList > amountOfLists || numberOfList < 0) throw out_of_range("Выход за пределы вектора.");
                        break;
                    } 
                    catch (const exception& ex) 
                    {
                        cerr << "Произошла ошибка: " << ex.what() << endl;
                        cin.clear();
                        cin.ignore(numeric_limits<streamsize>::max(), '\n');
                    }
                }
                
                while (true) // Ввод числа для добавления
                {
                    cout << endl << "Введите число которое хотите добавить в конец списка: ";
                    try 
                    {
                        cin >> value;
                        if (cin.fail()) throw invalid_argument("Ошибка ввода данных.");
                        break;
                    } 
                    catch (const exception& ex) 
                    {
                        cerr << "Произошла ошибка: " << ex.what() << endl;
                        cin.clear();
                        cin.ignore(numeric_limits<streamsize>::max(), '\n');
                    }
                }
 
                nList[numberOfList].append(value); // Добавление числа в конец
                break;
            }
            case 3:
            {
                while (true) // Ввод номера списка для взаимодействия
                {
                    cout << "Введите номер списка с которым хотите взаимодействовать: ";
                    try 
                    {
                        cin >> numberOfList;
                        if (cin.fail()) throw invalid_argument("Ошибка ввода данных.");
                        else if(numberOfList > amountOfLists || numberOfList < 0) throw out_of_range("Выход за пределы вектора.");
                        break;
                    } 
                    catch (const exception& ex) 
                    {
                        cerr << "Произошла ошибка: " << ex.what() << endl;
                        cin.clear();
                        cin.ignore(numeric_limits<streamsize>::max(), '\n');
                    }
                }
 
                while (true) // Ввод числа для добавления
                {
                    cout << "Введите число которое хотите добавить: ";
                    try 
                    {
                        cin >> value;
                        if (cin.fail()) throw invalid_argument("Ошибка ввода данных.");
                        break;
                    } 
                    catch (const exception& ex) 
                    {
                        cerr << "Произошла ошибка: " << ex.what() << endl;
                        cin.clear();
                        cin.ignore(numeric_limits<streamsize>::max(), '\n');
                    }
                }
 
                while (true) // Ввод числа для добавления
                {
                    cout << "Введите номер узла после которого необходимо ввести вставку: ";
                    try 
                    {
                        cin >> index;
                        if (cin.fail()) throw invalid_argument("Ошибка ввода данных."); 
                        break;
                    } 
                    catch (const exception& ex) 
                    {
                        cerr << "Произошла ошибка: " << ex.what() << endl;
                        cin.clear();
                        cin.ignore(numeric_limits<streamsize>::max(), '\n');
                    }
                }
                
                try
                {
                    // Добавление после узла
                    nList[numberOfList].insertAfter(value, index);
                }
                catch(const exception& ex)
                {
                    cerr << "Произошла ошибка: " << ex.what() << endl;
                }
                break;
            }
            case 4:
            {
                while (true) // Ввод номера списка для взаимодействия
                {
                    cout << "Введите номер списка с которым хотите взаимодействовать: ";
                    try 
                    {
                        cin >> numberOfList;
                        if (cin.fail()) throw invalid_argument("Ошибка ввода данных.");
                        else if(numberOfList > amountOfLists || numberOfList < 0) throw out_of_range("Выход за пределы вектора.");
                        break;
                    } 
                    catch (const exception& ex) 
                    {
                        cerr << "Произошла ошибка: " << ex.what() << endl;
                        cin.clear();
                        cin.ignore(numeric_limits<streamsize>::max(), '\n');
                    }
                }
 
                while (true) // Ввод числа для удаления
                {
                    cout << "Введите номер узла который необходимо удалить: ";
                    try 
                    {
                        cin >> index;
                        if (cin.fail()) throw invalid_argument("Ошибка ввода данных."); 
                        break;
                    } 
                    catch (const exception& ex) 
                    {
                        cerr << "Произошла ошибка: " << ex.what() << endl;
                        cin.clear();
                        cin.ignore(numeric_limits<streamsize>::max(), '\n');
                    }
                }
                
                try
                {
                    // Удаление узла
                    nList[numberOfList].remove(index);
                }
                catch(const exception& ex)
                {
                    cerr << "Произошла ошибка: " << ex.what() << endl;
                }
                break;
            }
            case 5:
            {
                while (true) // Ввод номера списка для взаимодействия
                {
                    cout << "Введите номер списка с которым хотите взаимодействовать: ";
                    try 
                    {
                        cin >> numberOfList;
                        if (cin.fail()) throw invalid_argument("Ошибка ввода данных.");
                        else if(numberOfList > amountOfLists || numberOfList < 0) throw out_of_range("Выход за пределы вектора.");
                        break;
                    } 
                    catch (const exception& ex) 
                    {
                        cerr << "Произошла ошибка: " << ex.what() << endl;
                        cin.clear();
                        cin.ignore(numeric_limits<streamsize>::max(), '\n');
                    }
                }
 
                while (true) // Ввод номера списка для приравнивания с выбранным ранее
                {
                    cout << "Введите номер списка к которому нужно приравнять выбранный список: ";
                    try 
                    {
                        cin >> numberOfAnotherList;
                        if (cin.fail()) throw invalid_argument("Ошибка ввода данных.");
                        else if(numberOfAnotherList > amountOfLists || numberOfAnotherList < 0) throw out_of_range("Выход за пределы вектора.");
                        break;
                    } 
                    catch (const exception& ex) 
                    {
                        cerr << "Произошла ошибка: " << ex.what() << endl;
                        cin.clear();
                        cin.ignore(numeric_limits<streamsize>::max(), '\n');
                    }
                }
 
                nList[numberOfList] = nList[numberOfAnotherList]; // Приравниваем листы
 
                break;
            }
            case 6:
            {
                printEveryList(nList, amountOfLists);
                break;
            }
            case 0:
                break;
        }
    } while (intOption != 0);
 
    
    return 0;
}