Die korrekte Umsetzung der doppelt verknüpften Liste Methoden

Question

Erste, sorry für mein schlechtes Englisch.

ich versuche, eine doppelt verknüpfte Liste zu implementieren, aber ich bin nicht sicher, ob einige seiner Methoden korrekt funktionieren. In der Tat, die clear(), remove(const short DATA) - was Entfernt alle Elemente, die zu DATA, unique() und reverse() gleich vergleichen funktioniert nicht korrekt funktionieren. Ich habe kein Buch, Video oder Artikel gefunden, was gut wäre. Ich konnte sie mir in den Weg implementieren, aber ich bleibe auf die formale Art und Weise (Wenn es) und eine erfahrene Person, die Lösung wäre effektiver als meine

void DLList::clear() 
{ 
    Node *pCurr = mHead; 
    while (pCurr != nullptr) 
    { 
     mHead = pCurr->mNext; 
     delete pCurr; 
     pCurr = mHead; 
    } 
} 

void DLList::remove(const short DATA) 
{ 
    Node *pCurr = mHead; 
    while (pCurr != nullptr) 
    { 
     if (pCurr->mData == DATA) 
     { 
      if (pCurr == mHead) 
      { 
       mHead = pCurr->mNext; 
       delete pCurr; 
       pCurr = mHead; 
      } 
      else 
      { 
       Node *pPrev = pCurr->mPrev; 
       pPrev->mNext = pCurr->mNext; 
       delete pCurr; 
       pCurr = pPrev->mNext; 
      } 
     } 
     else 
      pCurr = pCurr->mNext; 
    } 
} 

void DLList::unique() 
{ 
    Node *pCurr = mHead; 
    while (pCurr != nullptr) 
    { 
     Node *pNextDistinct = pCurr->mNext; 
     while (pNextDistinct != nullptr && pNextDistinct->mData == pCurr->mData) 
     { 
      pNextDistinct = pNextDistinct->mNext; 
      delete pCurr->mNext; 
      pCurr->mNext = pNextDistinct; 
      pNextDistinct->mPrev = pCurr; 
     } 
     pCurr = pNextDistinct; 
    } 
} 

void DLList::reverse() 
{ 
    Node *pPrev = nullptr; 
    Node *pCurr = mHead; 
    while (pCurr != nullptr) 
    { 
     pCurr->mPrev = pCurr->mNext; 
     pCurr->mNext = pPrev; 
     pPrev = pCurr; 
     pCurr = pCurr->mPrev; 
    } 
    mHead = pPrev; 
} 

Answer 1

ich Ihre Methoden korrigiert haben, so dass sie sollte gut funktionieren . Bitte vergleiche deine Fehler und lies auch meine Empfehlung im Code. Verwenden Sie beim Codieren der Datenstruktur immer Papier und Stift und notieren Sie sich zuerst die Baum- oder Listenstruktur, die Ihnen hilft, zuerst den Algorithmus zu entwerfen und dann zu codieren. Bitte lassen Sie mich wissen, wenn Sie weitere Hilfe benötigen.

//In the below method you are deleting unique nodes 
void DLList::unique() 
{ 
    Node *pCurr = mHead; 
    Node *temp = NULL; 
    int data = 0; 
    while (pCurr != NULL) 
    { 
     data = pCurr->mData; 
     temp = pCurr; 
     while(temp != NULL) 
     { 
      temp = temp->mNext; 
      if(temp->mData == data) 
      { 
       //delete the duplicate node 
       temp->mPrev->mNext = temp->mNext; 
       if(temp->mNext != NULL) 
        temp->mNext->mPrev = temp->mPrev; 
       delete(temp); 
      } 
     } 
     pCurr = pCurr->mNext; 
    } 
} 


void DLList::reverse() 
{ 
    Node *temp = NULL, *q = NULL; 
    while (temp->mNext != NULL) 
     temp = temp->mNext; 
    //now temp is pointing to the last node of the list 
    //Assume that mHead->mPrev == null, because I dont know whether it is null or address of Head itself 
    //if Head node mPrev is holding the address of head then you must store the address of head in a pointer 
    //to check whether you reach head node or not 
    //as I assume it is null so I don't need a temporary pointer here 
    mHead = temp; //now head is pointing to the last node 
    q = temp->mPrev;//pointer q is pointing to the previous node of the last node 
    temp->mPrev = NULL;//as last node is now first node make it's previous pointer as NULL 
    while(q!=NULL)// now traverse toward the old head node who's prev pointer is set as NULL 
    { 
     temp->mNext = q; 
     q->mPrev = temp; 
     temp = q; //move temp to the old previous node 
     q = q->mPrev;// Move q to the previous node 
    } 
    //Now temp is pointing to the old head node 
    temp->mNext = NULL;//Your list is reversed finally 
} 

Reversierung kann auch vom Kopf bis zum letzten Knoten durchgeführt werden. Jetzt schreibst du die Liste einfach auf und denkst dir, wie du es machen kannst und wie viel Zeiger du dafür brauchst. Viel Glück :-)