Переделать на Двусвязный список

#include <iostream>
#include <fstream>
#include <string.h>
#include <iomanip>
#include <stdlib.h>
using namespace std;
struct student
{
    char name[18];
    int number;
    int course;
};
int main()
{
    setlocale(LC_ALL,"Russian");
    int i;
    const int n=5;
    student study[n];
    ofstream result;
    result.open("result.txt",ios::out);
    ifstream fin;
    fin.open("student.txt",ios::in);
    for (i = 0; i < n; i++)
    {
        fin>>study[i].name;
        fin>>study[i].number;
        fin>>study[i].course;
 
    }
    for(i=0; i<n; i++)
          {
              if (study[i].number<study[i].number[i+1])
              {
              int b;
              b=study[i].number;
              study[i].number=study[i].number[i+1];
              study[i].number[i+1]=b;
              }
                result<<study[i].name <<setw(10)<< study[i].number<<setw(10)<<study[i].course<<endl;
                cout<<study[i].name <<setw(10)<< study[i].number<<setw(10)<<study[i].course<<endl;
 
         }
        result.close();
        fin.close();
        system("pause");
    return 0;
}

#include <iostream>
#include <string>
#include <fstream>
 
#ifndef LINKED2LIST_H
#define LINKED2LIST_H
 
#include <iostream>
#include <string>
#include <fstream>
#include <limits.h>
 
struct Student
{
    std::string name;
    int number;
    int course;
};
 
 
std::ostream& operator<<(std::ostream& ost, Student const& isl)
{
    return ost << isl.name << '\n' << isl.number << '\n' << isl.course;
}
 
// Uzel spiska
struct Node
{
    Student data;
    Node* pprev, *pnext;
    Node(Student const& rhs) : data(rhs), pprev(0), pnext(0){}
    Node* Add(Student const&);
    bool Remove(std::string const&);
    void Print(std::ostream&) const;
};
 
Node* Node::Add(Student const& rhs)
{
    Node* pret = 0;
    if(rhs.name < data.name)
    {
        Node* const ptmp = pprev;
        pprev = new Node(rhs);
        pprev->pnext = this;
        pprev->pprev = ptmp;
        ptmp->pnext = pprev;
        pret = pprev;
    }
    else if(rhs.name == data.name)
        pret = 0;
    else
    {
        if(pnext)
            pret = pnext->Add(rhs);
    }
    return pret;
}
 
bool Node::Remove(std::string const& name)
{
    bool bret = false;
    Node* ptmp = 0;
    if(name == pnext->data.name)
    {
        ptmp = pnext->pnext;
        ptmp->pprev = this;
        delete pnext;
        pnext = ptmp;
        ptmp = 0;
        bret = true;
    }
    else if(name > pnext->data.name)
        bret = pnext->Remove(name);
    return bret;
}
 
void Node::Print(std::ostream& ost = std::cout) const
{
    ost << data << "\n\n";
    if(pnext)
        pnext->Print(ost);
}
 
// Spisok
class List
{
public:
    List() : phead(0), ptale(0){}       // Konstruktor
    Node* Add(Student const&);           // Dobavlyaet ostrov v spisok, no esli ostrov s takim nazvaniem uje est' to on ne dobavlyaetsya
    bool Remove(std::string const&);    // Udalyaet ostrov s dannim imenem iz spiska
    bool LoadFile(std::string const&);  // Zagrujaet fail v spisok
    void DumpFile(std::string const&)const;     // Sohranyaet spisok v fail
    void Print(std::ostream&)const;     // Vivodit spisok na ekran
    ~List();                            // Destruktor
    struct Iterator
    {
    public:
        Iterator() : pnode(0){}
        Iterator(Node* prhs) : pnode(prhs){}
        Iterator& operator++()
        {
            if(pnode)
                pnode = pnode->pnext;
            return *this;
        }
 
        Student& operator*()
        {
            return pnode->data;
        }
 
        Student* operator->()
        {
            return &pnode->data;
        }
 
        bool operator!=(Iterator rhs)
        {
            return pnode != rhs.pnode;
        }
 
    private:
        Node* pnode;
    };
    Iterator Begin();
    Iterator End();
private:
    List(List const&);
    List& operator=(List const&);
    Node* phead, *ptale;
};
 
Node* List::Add(Student const& rhs)
{
    Node* pret = 0;
    if(!phead)
    {
        phead = new Node(rhs);
        ptale = phead;
        pret = phead;
    }
    else if(rhs.name < phead->data.name)
    {
        phead->pprev = new Node(rhs);
        phead->pprev->pnext = phead;
        phead = phead->pprev;
        pret = phead;
    }
    else if(rhs.name > ptale->data.name)
    {
        ptale->pnext = new Node(rhs);
        ptale->pnext->pprev = ptale;
        ptale = ptale->pnext;
        pret = ptale;
    }
    else
        pret = phead->Add(rhs);
    return pret;
}
 
bool List::Remove(std::string const& name)
{
    bool bret = false;
    if(phead && name >= phead->data.name && name <= ptale->data.name)
    {
        Node* ptmp = 0;
        if(name == phead->data.name)
        {
            ptmp = phead->pnext;
            if(ptmp)
                ptmp->pprev = 0;
            else
                ptale = 0;
            delete phead;
            phead = ptmp;
            ptmp = 0;
            bret = true;
        }
        else if(name == ptale->data.name)
        {
            ptmp = ptale->pprev;
            ptmp->pnext = 0;
            delete ptale;
            ptale = ptmp;
            ptmp = 0;
            bret = true;
        }
        else
            bret = phead->Remove(name);
    }
    return bret;
}
 
bool List::LoadFile(std::string const& filepath)
{
    bool bret = false;
    std::ifstream ifs(filepath.c_str());
    if(ifs.is_open())
    {
        Student tmp;
        while(std::getline(ifs, tmp.name))
        {
            ifs >> tmp.number >> tmp.course;
            if(!ifs)
                throw "LoadFile: operator>> failed\n";
            Add(tmp);
            ifs.ignore(100, '\n').ignore(100, '\n');
        }
        bret = true;
        ifs.close();
    }
    return bret;
}
 
void List::DumpFile(std::string const& filepath) const
{
    std::ofstream ofs(filepath.c_str());
    if(!ofs.is_open())
        throw "DumpFile: Unable to open output file\n";
    Print(ofs);
    ofs.close();
}
 
void List::Print(std::ostream& ost = std::cout) const
{
    if(phead)
        phead->Print(ost);
}
 
List::Iterator List::Begin()
{
    return List::Iterator(phead);
}
 
List::Iterator List::End()
{
    return List::Iterator();
}
 
List::~List()
{
    Node* ptmp = 0;
    while(phead)
    {
        ptmp = phead->pnext;
        delete phead;
        phead = ptmp;
    }
    ptale = 0;
}
 
 
#endif // LINKED2LIST_H
 
int main()
{
    List lst;
    Student std = {"Name2", 1234, 3};
    lst.Add(std);
    std = {"Name3", 71234, 1};
    lst.Add(std);
    std = {"Name1", 16234, 2};
    lst.Add(std);
    lst.Print();
    return 0;
}