Question

Hello, can someone help me solve the remove function since when I try to remove it doesn't work, please and thank you.

#include <iostream>
#include <cstdlib>
#include <string>

using namespace std;

class node
{
public:
   typedef int data_t;

   node *next;
   data_t data;

   node(data_t d) { next = NULL; data = d; }
};

class linked_list
{
private:
   node *head;

public:

   linked_list()
   {
       head = NULL;
   }

   // Get the size of linked list
   int size()
   {
       node *tptr = head;
       int c = 0;

       while (tptr)
       {
           c++;
           tptr = tptr->next;
       }

       return c;
   }

   void add(int n, node::data_t d)
   {
       /*
           tptr -> Iterate though the existing list
           prev -> Holds the previous node
           curr -> Holds the newly created node
           c -> Position of current node
       */
       node *tptr = head, *prev = head, *curr;
       int c = 1;

       // Exit on invalid position
       if (n < 1)  
           return;

       // Add at first position
       if (n == 1)
       {
           add_first(d);
           return;
       }

       // Add at last position
       // Example: Let's say the list already has 2 nodes, this handles if user tries to add new node at position 3
       if (size() == n - 1)
       {
           add_last(d);
           return;
       }

       // Iterate through the list and add new node at given position
       while (tptr)
       {
           if (c == n)
           {
               curr = new node(d);
               prev->next = curr;
               curr->next = tptr;
               break;
           }
           c++;
           prev = tptr;       // Hold the current node as previous node before traversing to next node
           tptr = tptr->next;
       }
   }

   void add_last(node::data_t d)
   {
       node *tptr = head;

       if (!head)
       {
           head = new node(d);
           return;
       }
       while (tptr->next)
       {
           tptr = tptr->next;
       }

       tptr->next = new node(d);
   }

   void add_first(node::data_t d)
   {
       node *newptr = new node(d);
       newptr->next = head;
       head = newptr;
   }

   node::data_t get(int n)
   {
       node *tptr = head;
       int c = 1;

       // Get details if requested for first node
       if (n == 1)
           return get_first();

       // Get details if requested for last node
       if (n == size())
           return get_last();

       // Iterate and get the details of requested node position
       while (tptr)
       {
           if (n == c)
               return tptr->data;

           tptr = tptr->next;
           c++;
       }

       // Return negative if giving position doesn't exists
       return -1;
   }

   node::data_t get_first()
   {
       // Return negative if no list is found
       if (!head)
           return -1;
      
       return head->data;   // Return first node details
   }

   node::data_t get_last()
   {
       node *tptr = head;

       // Return negative if no list is found
       if (!head)
           return -1;
  
       // Iterate through to get the last node
       while (tptr)
       {
           // If last node, return the data
           if (tptr->next == NULL)
               return tptr->data;

           tptr = tptr->next;
       }
   }

   void remove(int n)
   {
       /*
           tptr -> Holds current node
           prev -> Holds previous node
           c -> Position of current node
       */
       node *tptr = head, *prev = head;
       int c = 1;

       // Handle remove for first node
       if (n == 1)
       {
           remove_first();
           return;
       }

       // Handle remove for last node
       if (n == size())
       {
           remove_last();
           return;
       }

       // Handle removal at given node
       while (tptr)
       {
           if (c == n)
           {
               prev->next = tptr->next;   // Assign previous node to next node
               return;
           }
           c++;
           prev = tptr;
           tptr = tptr->next;
       }
   }

   void remove_first()
   {
       // Exit if head as no nodes
       if (!head)
           return;
      
       // Remove the first node
       head = head->next;
   }

   void remove_last()
   {
       /*
           tptr -> Holds current node
           prev -> Holds previous node
       */
       node *tptr = head, *prev = head;

       // Exit if head as no nodes
       if (!head)
           return;

       // Iterate to ge the last node
       while (tptr->next != NULL)
       {
           prev = tptr;
           tptr = tptr->next;
       }
      
       // Remove last node
       prev->next = NULL;
   }

   void dump()
   {
       node *tptr;

       cout << " DUMP: (size = " << size() << ", first = " << get_first() << ", last = " << get_last() << ") ";

       if (head == NULL) {
           cout << " DUMP: head = NULL ";
           return;
       }

       tptr = head;

       while (tptr) {
           cout << " DUMP: data = : " << tptr->data << endl;
           tptr = tptr->next;
       }
       cout << endl;
   }

};

int main(void)
{
   linked_list ll;
   string cmd;
   int i, d;

   while (cin >> cmd >> i >> d)
   {
       cout << "MAIN: cmd = " << cmd << ", i = " << i
           << ", d = " << d << endl;

       if (cmd == "add")
           ll.add(i, d);
       else if (cmd == "addf")
           ll.add_first(d);
       else if (cmd == "addl")
           ll.add_last(d);
       else if (cmd == "rem")
           ll.remove(i);
       else if (cmd == "remf")
           ll.remove_first();
       else if (cmd == "reml")
           ll.remove_last();
       else if (cmd == "get") {
           d = ll.get(i);
           cout << "get returns: " << d << endl;
       }
       else if (cmd == "getf") {
           d = ll.get_first();
           cout << "getf returns: " << d << endl;

       }
       else if (cmd == "getl") {
           d = ll.get_last();
           cout << "getl returns: " << d << endl;
       }
       else if (cmd == "dump")
           ll.dump();
       else if (cmd == "quit")
           exit(0);
   }
}

Answer 1

Code:

#include <iostream>
#include <cstdlib>
#include <string>

using namespace std;

class node {
public:
typedef int data_t;

node* next;
data_t data;

node(data_t d)
{
next = NULL;
data = d;
}
};

class linked_list {
private:
node* head;

public:
linked_list()
{
head = NULL;
}

int size()
{
node* tptr = head;

int c = 0;

while (tptr) {
c++;
tptr = tptr->next;
}

return c;
}

void add(int n, node::data_t d) // code to add element at given index
{
node *pre=new node;
node *cur=new node;
node *temp=new node;
cur=head;
for(int i=1;i<n;i++)
{
pre=cur;
cur=cur->next;
}
temp->data=d;
pre->next=temp;
temp->next=cur;

}

void add_last(node::data_t d)
{
node* tptr = head;

if (!head) {
head = new node(d);
return;
}
while (tptr->next) {
tptr = tptr->next;
}

tptr->next = new node(d);
}

void add_first(node::data_t d)
{
node* newptr = new node(d);

newptr->next = head;

head = newptr;
}
node::data_t get(int n);

node::data_t get_first();

node::data_t get_last();
{
node* tptr = head;

if (head)
}

void remove(int n) // delete node at nth index
{
node *current=new node;
node *previous=new node;
current=head;
for(int i=1;i<pos;i++)
{
previous=current;
current=current->next;
}
previous->next=current->next;
}

void remove_first() // delete from first
{
node *temp=new node;
temp=head;
head=head->next;
delete temp;
}

void remove_last() // delete from last
{
node *current=new node;
node *previous=new node;
current=head;
while(current->next!=NULL)
{
previous=current;
current=current->next;
}
tail=previous;
previous->next=NULL;
delete current;
}

int get(int n) // find element at given index
{
struct Node* current = head;
int count = 0;
while (current != NULL)
{
if (count == n)
return(current->data);
count++;
current = current->next;
}
assert(0);
}
int get_first(); // find head of list
{
return head->data;
}
int get_last(); // find tail of list
{
struct Node* temp = head;
if (temp == NULL)
return -1;
while (temp != NULL)
{
if (temp->next==NULL)
return temp->data;
temp = temp->next;
}
}

void dump()
{
node* tptr;

cout << " DUMP: (size = " << size() << ", first = " << get_first() << ", last = " << get_last() << ")\n";

if (head == NULL) {
cout << " DUMP: head = NULL\n\n";
return;
}

tptr = head;

while (tptr) {
cout << " DUMP: data = : " << tptr->data << endl;
tptr = tptr->next;
}
cout << endl;
}
};

int main(void)
{
linked_list ll;
string cmd;
int i, d;

while (cin >> cmd >> i >> d) {
cout << "MAIN: cmd = " << cmd << ", i = " << i
<< ", d = " << d << endl;

if (cmd == "add")
ll.add(i, d);
else if (cmd == "addf")
ll.add_first(d);
else if (cmd == "addl")
ll.add_last(d);
else if (cmd == "rem")
ll.remove(i);
else if (cmd == "remf")
ll.remove_first();
else if (cmd == "reml")
ll.remove_last();
else if (cmd == "get") {
d = ll.get(i);
cout << "get returns: " << d << endl;
}
else if (cmd == "getf") {
d = ll.get_first();
cout << "getf returns: " << d << endl;
}
else if (cmd == "getl") {
d = ll.get_last();
cout << "getl returns: " << d << endl;
}
else if (cmd == "dump")
ll.dump();
else if (cmd == "quit")
exit(0);
}
}