ED

#include <iostream>
#include <string>

using namespace std;

typedef struct DNODE* PDNODE;

typedef struct DNODE {
    string sNombre;
    int sFrec;
    PDNODE sNext;
    PDNODE sPrev;
};

class DList
{
protected:
    PDNODE aHead;
    PDNODE aTail;
    PDNODE aCurr;
    bool pForce;
    bool aFrec;

public:
    DList(void);
    ~DList(void);

    void clean(void);

    void push_front(string pNombre);
    void push_back(string pNombre);
    void push(string pNombre);

    void repr(bool pRev= false);

    PDNODE top_front(void);
    PDNODE top_back(void);
    PDNODE get(bool pRev=false);

    void pop_front(void);
    void pop_back(void);
    void del(string pNombre, bool pForce);

    bool isEmpty(void);

private:
    PDNODE getNewNode(string pNombre);
    PDNODE search(string pNombre);
    PDNODE find(string pNombre);
};

DList::DList(void)
{
    aHead = NULL;
    aTail = NULL;
    aCurr = NULL;
    aFrec = true;
    pForce = false;
} //Constructor

DList::~DList(void)
{
    clean();
} //Destructor

void DList::clean(void)
{
    while (aHead)
    {
        PDNODE lTemp = aHead->sNext;
        delete aHead;
        aHead = lTemp;
    }

    aHead = NULL;
    aTail = NULL;
} //clean

void DList::push_front(string pNombre)
{
    if (aHead == NULL)
    {
        aHead = getNewNode(pNombre);
        aTail = aHead;
    }
    else
    {
        if(aFrec){
            PDNODE lItem = find(pNombre);
            if(lItem){
                aHead->sFrec++;
            }else{
                PDNODE lTemp = getNewNode(pNombre);
                lTemp->sNext = aHead;
                aHead->sPrev = lTemp;
                aHead = lTemp;
            }
        }else {
            PDNODE lTemp = getNewNode(pNombre);
            lTemp->sNext = aHead;
            aHead->sPrev = lTemp;
            aHead = lTemp;
        }
    }
} //push front

void DList::push_back(string pNombre)
{
    if (aHead == NULL)
    {
        aHead = getNewNode(pNombre);
        aTail = aHead;
    }
    else
    {
        if(aFrec){
            PDNODE lItem = find(pNombre);
            if(lItem){
                aTail->sFrec++;
            }else{
                PDNODE lTemp = getNewNode(pNombre);
                aTail->sNext = lTemp;
                lTemp->sPrev = aTail;
                aTail = lTemp;
            }
        }else {
            PDNODE lTemp = getNewNode(pNombre);
            aTail->sNext = lTemp;
            lTemp->sPrev = aTail;
            aTail = lTemp;
        }
    }
} //push back

void DList::push(string pNombre)
{
    if (aHead == NULL)
    {
        aHead = getNewNode(pNombre);
        aTail = aHead;
    }
    else
    {
        if (pNombre <= aHead->sNombre)
        {
            push_front(pNombre);
        }
        else
        {
            if (pNombre >= aTail->sNombre)
            {
                push_back(pNombre);
            }
            else
            {
                if(aFrec){
                    PDNODE lIQ = find(pNombre);
                    if(lIQ){
                        lIQ->sFrec++;
                    }else {
                        PDNODE lItem = search(pNombre);
                        if (lItem) {
                            PDNODE lTemp = getNewNode(pNombre);
                            lTemp->sNext = lItem;
                            lTemp->sPrev = lItem->sPrev;
                            lItem->sPrev->sNext = lTemp;
                            lItem->sPrev = lTemp;
                        }
                    }
                }else {
                    PDNODE lItem = search(pNombre);
                    if (lItem) {
                        PDNODE lTemp = getNewNode(pNombre);
                        lTemp->sNext = lItem;
                        lTemp->sPrev = lItem->sPrev;
                        lItem->sPrev->sNext = lTemp;
                        lItem->sPrev = lTemp;
                    }
                }
            }
        }
    }
}//push

PDNODE DList::top_front(void)
{
    if (aHead)
    {
        return aHead;
    }
    return NULL;
}// top back
PDNODE DList::top_back(void)
{
    if (aHead)
    {
        return aTail;
    }
    return NULL;
} //top back

PDNODE DList::get(bool pRev)
{
    PDNODE lTemp = NULL;
    if (aHead)
    {
        if (aCurr == NULL)
            aCurr = (pRev ==false ? aHead: aTail);
        else
            aCurr = (pRev == false ? aCurr->sNext: aCurr->sPrev);
        lTemp = aCurr;
    }
    return lTemp;

}//get

void DList::pop_front(void)
{
    if (aHead)
    {
            PDNODE lTemp = aHead->sNext; //guarda la dirección del siguiente antes de hacer el delete
            bool lEqual = (aHead == aCurr);
            delete aHead;
            aHead = lTemp;
            if (aHead == NULL) //significa que teniamos un unico nodo
            {
                aTail = NULL; //aTail no existe
                aCurr = NULL;
            } else {
                aHead->sPrev = NULL; //ya no tiene nada atrás entonces se vuelve nulo
                aCurr = (lEqual ? aHead : aCurr); // si pasa igual, se mueve al nuevo head, sino se queda donde esta
            }
        }
} //pop front

void DList::pop_back(void)
{
    if (aHead)
    {
            PDNODE lTemp = aTail->sPrev; //guarda la dirección del anterior antes de hacer el delete
            bool lEqual = (aTail == aCurr);
            delete aTail;
            aTail = lTemp;
            if (aTail == NULL) //significa que teniamos un unico nodo
            {
                aHead == NULL; //aHead no existe
                aCurr = NULL;
            } else {
                aTail->sNext = NULL; //ya no tiene nada adelante entonces se vuelve nulo
                aCurr = (lEqual ? aTail : aCurr); // si pasa algo se mueve al tail nuevo, sino se queda donde esta
            }
    }
} //pop back

PDNODE DList::getNewNode(string pNombre)
{
    PDNODE lTemp = new DNODE;
    if (lTemp)
    {
        lTemp->sNombre = pNombre;
        lTemp->sFrec = 1;
        lTemp->sNext = NULL;
        lTemp->sPrev = NULL;
    }
    return lTemp;
}// getnewnode

bool DList::isEmpty(void)
{
    return (aHead == NULL);
}//isEmpty

void DList::repr(bool pRev)
{
    if (aHead)
    {
        PDNODE lTemp = (pRev== false ? aHead : aTail);
        while (lTemp) {
            if (aFrec) {
                for(int i = 0; i<lTemp->sFrec; i++){
                    cout << "-> " << lTemp->sNombre;
                }
                lTemp = (pRev == false ? lTemp->sNext : lTemp->sPrev);
            } else {
                cout << "-> " << lTemp->sNombre;
                lTemp = (pRev == false ? lTemp->sNext : lTemp->sPrev);
            }
        }
        cout << " ->||" << endl;

    }
}//repr

PDNODE DList::search(string pNombre)
{
    PDNODE lTemp = aHead;

    while (lTemp)
    {
        if (pNombre <= lTemp->sNombre)
        {
            return lTemp;
        }
        lTemp = lTemp->sNext;
    }

    return NULL;
}  //Search

PDNODE DList::find(string pNombre)
{
    PDNODE lTemp = aHead;

    while (lTemp)
    {
        if (pNombre == lTemp->sNombre)
        {
            return lTemp;
        }
        lTemp = lTemp->sNext;
    }

    return NULL;
}

void DList::del(string pNombre, bool pForce) {
    if(aHead){
        if(!pForce){
            if(aFrec && aFrec>1) {
                PDNODE lIQ = find(pNombre);
                if (lIQ) {
                    lIQ->sFrec--;
                }else {
                    if (pNombre == aHead->sNombre) {
                        pop_front();
                    } else {
                        if (pNombre == aTail->sNombre) {
                            pop_back();
                        } else {

                            PDNODE lItem = find(pNombre);
                            if (lItem) {
                                lItem->sPrev->sNext = lItem->sNext;
                                lItem->sNext->sPrev = lItem->sPrev;
                                delete lItem;
                            }
                        }
                    }
                }
            }
        }else {
            if (pNombre == aHead->sNombre) {
                pop_front();
            } else {
                if (pNombre == aTail->sNombre) {
                    pop_back();
                } else {

                    PDNODE lItem = find(pNombre);
                    if (lItem) {
                        lItem->sPrev->sNext = lItem->sNext;
                        lItem->sNext->sPrev = lItem->sPrev;
                        delete lItem;
                    }
                }
            }
        }
    }
}
//Search

int main()
{
    DList lLista = DList();
    lLista.push("Peter Parker");
    lLista.push("Peter Parker");
    lLista.push("Peter Parker");
    lLista.push("Clark Kent");
    lLista.push("Diana Prince");
    lLista.push("Diana Prince");
    lLista.push("Diana Prince");
    lLista.push("007");
    lLista.push("alice");
    lLista.push("alice");
    lLista.push("alice");

    lLista.repr(true); //en codigo ASKI los numeros van primero, despues las mayusculas y despues las minusculas

    PDNODE  lTemp = NULL;
    while ((lTemp = lLista.get(true)))
    {
        cout << "Nom: " << lTemp->sNombre << endl;
    }

    lLista.repr(false);

    lLista.del("alice",true);
    cout<<"------"<<endl;
    lLista.repr(true);

    /*
    PDNODE lPtr = lLista.top_front();
    if (lPtr)
    {
        cout << "1ero: " << lPtr->sNombre << endl;

    }
    lLista.pop_front();
    lLista.repr();
    lLista.pop_back();
    lLista.repr();

    while (! lLista.isEmpty())
    {
        lLista.pop_front();
    }
    lLista.repr();
    */

}