Двунаправленный список: удалить все записи о книгах по заданной специальности

#include <iostream>
#include <string> 
#include <fstream>
using Marks = int[5];
struct STUDENT 
{
    std::string FIO;
    short course;
    short groupe;
    Marks marks;
    STUDENT() {};//конструктор
    STUDENT(std::ifstream& file);//каркас чтения одного студента
    void print(); 
    int compare(const STUDENT& student); 
    int kind(); 
};
 
struct NODE 
{
    
    STUDENT info;
    NODE* next;
    NODE* prev;
    NODE(STUDENT student, NODE* next = nullptr, NODE* prev = nullptr) :info(student), next(next),prev(prev) {};
    ~NODE() { next = nullptr; prev = nullptr; }
};
 
using ptrNODE = NODE*;
 
struct DoublyLinkedList
{
    ptrNODE begin, end;
    size_t size; //самостоятельно добавить
    DoublyLinkedList() { begin = nullptr; end = nullptr; }
    DoublyLinkedList(const char* file_name); //CreateOrder
    void First_node(const STUDENT& student);
    bool Empty();
    void Add_after_node(ptrNODE pNode, const STUDENT& student);
    void Add_before_node(ptrNODE pNode, const STUDENT& student);
    STUDENT& Delete(ptrNODE& pNode);
    void Print();
    ~DoublyLinkedList();
};
 
void task_1(DoublyLinkedList& Dlist)
{
    ptrNODE ptr = Dlist.begin;
    while (ptr)
    {
        if (ptr->info.kind() == 2)
            Dlist.Delete(ptr);
        else
            ptr = ptr->next;
    }
}
 
int task_2(const DoublyLinkedList& Dlist)
{
    int result = 0;
    int count = 0;
    int max = 0;
    ptrNODE ptr = Dlist.begin;
    int cur_course = ptr->info.course;
    while (ptr)
    {
        if (ptr->info.course == cur_course)
        {
            if (ptr->info.kind() == 5)
                count++;
            ptr = ptr->next;
        }
        else
        {
            if (count > max)
            {
                max = count;
                result = cur_course;
            }
            cur_course = ptr->info.course;
            count = 0;
        }
    }
    if (count > max)
    {
        //max = count;
        result = cur_course;
    }
    return result;
}
 
int main()
{
    //DoublyLinkedList Dlist;
    std::ifstream file("data.txt");
    //проверка файла
    DoublyLinkedList Dlist("data.txt");
    Dlist.Print();
    task_1(Dlist);
    Dlist.Print();
    int course = task_2(Dlist);
    if (course)
        std::cout << course << 'n';
    else
        std::cout << "No\n";
    std::cin.get();
    return 0;
}
 
STUDENT::STUDENT(std::ifstream& file)
{
    std::getline(file, FIO);
    file >> course >> groupe;
    for (short i = 0; i < 5; i++)
        file >> marks[i];
    file.ignore();
    std::string delim_line;
    std::getline(file, delim_line);
}
 
void STUDENT::print()
{
    std::cout << FIO << '\n';
    std::cout << course << '\n' << groupe << '\n';
    for (short i = 0; i < 5; i++)
        std::cout << marks[i] << ' ';
    std::cout << "\n------------------\n";
}
 
int STUDENT::compare(const STUDENT& student)
{
    int result = 1;
    if (course < student.course ||
        course == student.course && groupe < student.groupe ||
        course == student.course && groupe == student.groupe && FIO < student.FIO)
        result = -1;
    else
        if (course == student.course && groupe == student.groupe && FIO < student.FIO)
            result = 0;
    return result;
}
 
int STUDENT::kind()
{
    int result = marks[0];
    for (int i = 0; i < 5; i++)
        if (marks[i] < result)
            result = marks[i];
    return result;
}
 
ptrNODE Find_place(ptrNODE begin, const STUDENT& student)
{
    ptrNODE p = begin;
    while (p && p->info.compare(student) < 0)
        p = p->next;
    return p;
}
 
DoublyLinkedList::DoublyLinkedList(const char* file_name)
{
    std::ifstream file(file_name);
    STUDENT student(file);
    First_node(student);
    ptrNODE place;
    while (!file.eof())
    {
        STUDENT student(file);
        place = Find_place(begin, student);
        if (place)
            Add_before_node(place, student);
        else
            Add_after_node(end, student);
    }
    file.close();
}
 
void DoublyLinkedList::First_node(const STUDENT& student)
{
    begin = new NODE(student);
    end = begin;
}
 
bool DoublyLinkedList::Empty()
{
     return begin == nullptr;
}
 
void DoublyLinkedList::Add_after_node(ptrNODE pNode, const STUDENT& student)
{
    ptrNODE p = new NODE(student, pNode->next, pNode);
    if (pNode == end)
        end = p;
    else
        pNode->next->prev = p;
    pNode->next = p;
}
 
void DoublyLinkedList::Add_before_node(ptrNODE pNode, const STUDENT& student)
{
    ptrNODE p = new NODE(student, pNode, pNode->prev);
    if (pNode == begin)
        begin = p;
    else
        pNode->prev->next = p;
    pNode->prev = p;
}
 
STUDENT& DoublyLinkedList::Delete(ptrNODE& pNode)
{
    ptrNODE p = pNode;
    if (pNode == begin)
    {
        begin = p->next;
        pNode = begin;
        if (p->next)
            p->next->prev = nullptr;
    }
    else
        if (pNode == end)
        {
            end = p->prev;
            pNode = end;
            if (p->prev)
                p->prev->next = nullptr;
        }
        else
        {
            pNode = pNode->next;
            p->next->prev = p->prev;
            p->prev->next = p->next;
        }
    static STUDENT student;
    student = p->info;
    delete p;
    return student;
}
 
void DoublyLinkedList::Print()
{
    ptrNODE ptr = begin;
    while (ptr)
    {
        ptr->info.print();
        ptr = ptr->next;
    }
}
 
DoublyLinkedList::~DoublyLinkedList()
{
    while (!Empty())
        Delete(begin);
    //проверка на утечку тут
}