Question

I need help with understanding dummy nodes in doubly-linked lists.

Here is the code that I have right now.

************city.h****************

#ifndef city_h

#define city_h

#include <string>

using namespace std;

class City{

public:

City () {

name = "N/A";

population = 0;

}

City (string nm, unsigned int pop){

name = nm;

population = pop;

}

void setName (string name) {

this -> name = name;

}

void setPopulation (unsigned int population){

this -> population = population;

}

string getName() const {

return this -> name;

}

unsigned int getPopulation() const {

return this -> population;

}

virtual void printInfo() const {

cout << getName() << ": " << getPopulation() << endl;

}

protected:

string name;

unsigned int population;

};

#endif /* city_h */

************citynode.h***************

#ifndef citynode_h

#define citynode_h

#include <string>

#include "city.h"

class CityNode {

public:

City data;

CityNode *next;

CityNode *prev;

CityNode (City city){

data = city;

next = nullptr;

}

};

#endif /* citynode_h */

********************citylist.h********************

#ifndef citylist_h

#define citylist_h

#include<string>

#include<list>

#include "citynode.h"

using namespace std;

class CityList{

public:

CityList(){

head = tail = nullptr;

}

void append(CityNode *cityNode){

if(tail == nullptr){

head = tail = cityNode;

return;

}

tail -> next = cityNode;

cityNode -> prev = tail;

tail = tail -> next;

}

void prepend(CityNode *cityNode){

if(head == nullptr){

head = tail = cityNode;

return;

}

cityNode -> next = head;

head -> prev = cityNode;

head = cityNode;

}

void printCityList(){

CityNode *temp = head;

while(temp != nullptr){

cout << temp->data.getName() << " " << temp -> data.getPopulation() << endl;

temp = temp -> next;

}

}

CityNode *search(string cityName){

CityNode *temp = head;

while (temp != nullptr){

if(temp -> data.getName() == cityName){

return temp;

temp = temp -> next;

}

}

return nullptr;

}

void insert(CityNode *currNode, CityNode *cityNode) {

   if(currNode == nullptr) {

   head = tail = cityNode;

   return;

   }

   else if(currNode->next == tail) {

   tail->next = cityNode;

   cityNode->prev = tail;

   tail = cityNode;

   return;

   }

   else {

   cityNode->next = currNode->next;

   cityNode->next = cityNode->prev;

   cityNode->prev = currNode;

   currNode->next = cityNode;

   cityNode->prev = cityNode;

   }

   }

       void remove(CityNode *currNode) {

   if(currNode == nullptr || currNode->next == nullptr) {

   if(currNode == head) {

   free(head);

   head = nullptr;

   }

   return;

   }

   CityNode *temp = currNode->next;

   currNode->next = currNode->next->next;

   free(temp);

   }

  

private:

CityNode *head;

CityNode *tail;

};

#endif /* citylist_h */

*****************main.cpp*********************

#include <iostream>

#include "citylist.h"

using namespace std;

City cityArray[] = {{"Los Angeles", 4340174}, {"San Diego", 1591688},{"San Francisco", 871421}, {"Sacramento", 505628}, {"Stockton", 323761}, {"Redding", 90292}, {"Las Vegas", 711926}, {"Reno", 289485}, {"Portland", 730428}, {"Seattle", 752180}, {"Eugene", 221452}};

CityList cityList1, cityList2;

void initCityListByAppend(CityList &city1, City arr[], int size){

for(int i = 0; i < size; i++){

CityNode *cityNode = new CityNode(arr[i]);

city1.append(cityNode);

}

}

void initCityListByPrepend(CityList &city2, City arr[], int size){

for(int i = 0; i < size; i++){

CityNode *cityNode = new CityNode(arr[i]);

city2.prepend(cityNode);

}

}

int main() {

cout << "Initialize cityList1 according to array cityArray[] by appending: " << endl;

initCityListByAppend(cityList1, cityArray, 11);

cityList1.printCityList();

cout << endl;

cout << "Initializing cityList2 with cityArray[] using prepending: " << endl;

initCityListByPrepend(cityList2, cityArray, 11);

cityList2.printCityList();

cout << endl;

  

cout << "Searching for Stockton in cityList, and inserting Phoenix after it:" << endl;

   CityNode *k = cityList1.search("Stockton");

   if(k == nullptr) {

   cout << "Not found " <<endl;

   }

   else {

   City phoenixCity("Phoenix", 1660472);

   CityNode *cityNode = new CityNode(phoenixCity);

   cityList1.insert(k, cityNode);

   cityList1.printCityList();

   }

   cout << endl;

  

cout << "Searching for Reno in cityList, and removing the node after it:" << endl;

   k = cityList2.search("Reno");

   if(k == nullptr) {

   cout << "Not found " <<endl;

   }

   else {

   cityList2.remove(k);

   cityList2.printCityList();

   }

system("pause");

}

Question:

Consider class CityList that implements the doubly-linked list of cities with dummy node. It keeps track of the first and last elements of the list (through head and tail pointers, respectively).

#ifndef CITYLIST_H

#define CITYLIST_H

#include<string>

#include "citynode.h"

class CityList {

public:

CityList() { head = tail = new CityNode(City());}

void append(CityNode*cityNode);

void prepend(CityNode*cityNode);

void printCityList();

CityNode *search(string cityName);

void insert(CityNode*currNode, CityNode*cityNode);

void remove(CityNode*currNode);

private:

CityNode*head;

CityNode*tail;

};

#endif

Note that the dummy node is created upon constructing the list, and head and tail point to it.

1. Redefine void append(...) function considering the fact that CityList starts with a dummy node. This would make its definition simpler.

2. Redefine void prepend(...) function considering the fact that CityList starts with a dummy node. This would make its definition simpler.

3. Redefine CityNode*search(...) function considering the fact that CityList starts with a dummy node. This would make its definition slightly different.

4. Redefine void printCityList() function considering the fact that CityList starts with a dummy node. This would make its definition slightly different.

5. Redefine void insert(...) function considering the fact that CityList starts with a dummy node. This would make its definition simpler.

6. Redefine void remove(...) function considering the fact that CityList starts with a dummy node. This would make its definition simpler.

Answer 1

Given below is the modified code for the question. Please do rate the answer if it helped. Thank you.

citynode.h (fixed this to set prev pointer in constructor)
-----
#ifndef citynode_h
#define citynode_h

#include <string>
#include "city.h"

class CityNode {

public:

City data;

CityNode *next;

CityNode *prev;

CityNode (City city){

data = city;
prev = nullptr;
next = nullptr;

}

};

#endif /* citynode_h */

citylist.h
------
#ifndef citylist_h
#define citylist_h

#include<string>
#include "citynode.h"

using namespace std;

class CityList{

public:

   CityList(){
       head = tail = new CityNode(City()); //dummy node
   }

   void append(CityNode *cityNode){
       tail -> next = cityNode;
       cityNode -> prev = tail;
       tail = tail -> next;
   }

   void prepend(CityNode *cityNode){
       cityNode->next = head->next;
       head->next = cityNode;
       cityNode -> prev = head;
       if(tail == head)
           tail = cityNode;
   }

   void printCityList(){
       CityNode *temp = head->next;
       while(temp != nullptr){
           cout << temp->data.getName() << " " << temp -> data.getPopulation() << endl;
           temp = temp -> next;

       }
   }

   CityNode *search(string cityName){
       CityNode *temp = head->next;
       while (temp != nullptr){
           if(temp -> data.getName() == cityName)
               return temp;
           temp = temp -> next;
       }
       return nullptr;
   }

   void insert(CityNode *currNode, CityNode *cityNode) {
       cityNode->next = currNode->next;
       currNode->next= cityNode;
       cityNode->prev = currNode;
       if(tail == currNode)
           tail = cityNode;
   }
   void remove(CityNode *currNode) {
       if(currNode == nullptr)
           return;
      
       CityNode *nodeToDel = currNode->next;

       if(nodeToDel != nullptr){
           CityNode *next = nodeToDel->next;
           currNode->next = next;
           if(next != nullptr)
               next->prev = currNode;
           else
               tail = currNode;
           delete nodeToDel;
       }
   }

private:

CityNode *head;
CityNode *tail;

};

#endif /* citylist_h */