Storing elements of array in linked list

Question

This is my code to append an integer in linked list.

#include "iostream"
using namespace std;

class LinkList
{
private:
      struct Node
      {
        int data;
        Node* link;
      }*p;

public:
      LinkList();
      ~LinkList();

       void Print();         // Prints the contents of linkedlist
       void Append(int num); // Adds a new node at the end of the linkedlist
       void Delete(int num); // Deletes the specified node from the linkedlist

       void AddatBeg(int num);// Adds a new node at the beginning of the linkedlist
       void AddAfter(int c, int num); // Adds a new node after specified number of nodes
       int Count();          // Counts number of nodes present in the linkedlist

};

LinkList::LinkList()
{
  p = NULL;
}

LinkList::~LinkList()
{
  if (p == NULL)
        return;

  Node* tmp;
  while(p != NULL)
  {
       tmp = p->link ;
     delete p;
       p = tmp;
  }
}

// Prints the contents of linkedlist
void LinkList::Print()
{
  if (p == NULL)
  {
        cout<< "EMPTY";
        return;
  }

  //Traverse
  Node* tmp = p;
  while(tmp != NULL)
  {
       cout<<tmp->data<<endl;
       tmp = tmp->link ;
  }
}

// Adds a new node at the end of the linkedlist
void LinkList::Append(int num)
{
      Node *newNode;

      newNode = new Node;
      newNode->data = num;
      newNode->link = NULL;

       if(p == NULL)
      {
       //create first node
         p = newNode;
      }
       else
      {
             //Traverse
            Node *tmp = p;
             while(tmp->link != NULL)
            {
                  tmp = tmp->link;
            }

             //add node to the end
        tmp->link = newNode;
      }
}

// Deletes the specified node from the linkedlist
void LinkList::Delete( int num )
{
   Node *tmp;

   tmp = p;
   //If node to be delete is first node
   if( tmp->data == num )
   {
      p = tmp->link;
      delete tmp;
      return;
   }

   // traverse list till the last but one node is reached
   Node *tmp2 = tmp;
   while( tmp!=NULL )
   {
      if( tmp->data == num )
      {
         tmp2->link = tmp->link;
         delete tmp;
         return;
      }

      tmp2 = tmp;
      tmp = tmp->link;
   }
   cout<< "\nElement "<<num<<" not Found." ;
}

int LinkList::Count()
{
      Node *tmp;
       int c = 0;

       //Traverse the entire Linked List
       for (tmp = p; tmp != NULL; tmp = tmp->link)
            c++;

       return (c);
}

int main()
{
      LinkList* pobj = new LinkList();
      pobj->Append(11);
      pobj->Print();

       delete pobj;
       return 0;
}

What I am looking for is a code where I can insert elements of arrays in linked list. For example, if there are two arrays containing elements (1,2,3) and (4,5,6), Code should create two Linked lists and the address of first node of each linked list should be stored in an array so that running a for loop would print all linked list in sequence. Example:

Linked List 1 = (1,2,3)
Linked List 2 = (4,5,6)

Number of arrays and number of elements inside arrays will be dynamic.

Answer 1

NOTE: I suppose that your question is for learning purposes. If not, please not implement your own linked list, use std::vector. Prefer vector to std::list, linked lists have less performance than vectors, because cache misses. Check this question about performance comparisons between std::list and syd::vector.

Linked lists are commonly implemented as double-linked lists, to make push_back and pop_back operations O(1) (That is, no traverse needed for push_back).

The way to implement this is storing in the node not only a link to the next node, also a link to the previous node:

struct node
{
    node* previous;
    node* next;
    int data;
};

And the linked list class stores a node that represents the end of the list, in addition to the starting node:

node* begin;
node* end;

Note that I said "A node that represents the end of the list", not "the last node of the list". That is, end->previous points to the last node of the list. end->next points to anything (nullptr). Check this picture.

So by this way, push_back implementation only puts end->preious pointing to the new node (and new_node->next pointing to end), and new_node->previous pointing to the value of end->previous after the insertion.

Answer 2

Then you should use this a 2D vector std::vector< std::vector<int> > vect;