Question

C++: I need implement this code using Double Linked List using the cosiderations

1. head point to null in an empty list
2. There is not need of a tail pointer

/*This class implements the singly linked list using templates
Each list has two attributes:
   -head: first node in the list
   -tail: last node in the list

#include "circDLLNode.h"

template
class {
public:
   //Default constructor: creates an empty list
   ();

   //Destructor: deallocate memory
   ~();  

   //addToHead(T val): creates a new node with val as info,
   //and this new node is the new head
   void addToHead(T val);

   //addToTail(T val): creates a new node with val as info,
   //and this new node is the new tail   
   void addToTail(T val);

   //deleteFromHead: remove head from the list,
   //the new head is the previous head->next
   //if the list had only one node, head and tail point null
   void deleteFromHead();

   //deleteFromTail: remove tail from the list,
   //the new tail is the previous node to tail
   //if the list had only one node, head and tail point null
   void deleteFromTail();

   //In the list is empty, returns true
   //otherwise, returns false
   bool isEmpty();

   //sortInsert(T val): creates a new node, and it is inserted sortly
   void sortInsert(T val);

   //insert(int pos, T val): creates a new node, and it is inserted in position pos
   void insert(int pos, T val);

   //printList(): prints all nodes in the list from head to tail
   void printList();

   //printList(): prints all nodes in the list from tail to head
   void printRevList();

private:
   circDLLNode *head; //A pointer to the first node
};

/****************
   Default constructor: creates an empty list
   head and tail point null
*****************/
template
::()
{
   head = 0;
}
/***********************
   Destructor: deallocate memory removing each node from the list
*****************/
template
::~()
{
   while(!isEmpty())  
       this->deleteFromHead();
}

/***********************
   Implement other methods
  
***********************/

template
void :: addToHead(T val)

{



   circDLLNode *node = new circDLLNode(val);

   node->setNext(head);

   if(head == NULL)
       tail = node;
       head = node;
}

template

void circDLList:: addToTail(T val)
{

   circDLLNode *node = new circDLLNode(val);
   node->setNext(NULL);

   if(head == NULL)
   {
       head = node;
   }else
   {
       tail->setNext(node);
   }

   tail = node;
}

template

void circDLList:: deleteFromHead()
{

   if(!isEmpty())
   {
       circDLLNode *node = head;
     
       head = head->next;
     
       delete(node);
     
       if(head == NULL)
           tail = NULL;
   }
}

template

void circDLList:: deleteFromTail()
{

   if(!isEmpty())
   {

       circDLLNode *curr = head;
       circDLLNode *prev = NULL;
     
       while(curr->next != NULL)
       {
           prev = curr;
           curr = curr->next;
       }

     
       if(prev != NULL)
           prev->next = NULL;
       else
           head = NULL;
       tail = prev;

       delete(curr);
   }
}

template

bool circDLList:: isEmpty()
{
   return(head == NULL);
}

template
void circDLList:: sortInsert(T val)
{
   circDLLNode *node = new circDLLNode(val);
   if(head == NULL)
       head = node;
   else
   {
       circDLLNode *curr = head;
       circDLLNode *prev = NULL;

     
       while(curr != NULL)
       {
         
           if(curr->getVal() > val)
           {
             
               if(prev == NULL)
               {
                   node->setNext(head);
                   head = node;
               }else
               {
                   node->setNext(curr);
                   prev->setNext(node);
               }

               return ;
           }

           prev = curr;
           curr = curr->getNext();
       }
       tail->setNext(node);
       tail = node;
   }
}

template

void circDLList:: insert(int pos, T val)
{
   if((pos == 0) || (head == NULL ))
       addToHead(val);
   else
   {
       circDLLNode *node = new circDLLNode(val);
       int idx = 0;
       circDLLNode *curr = head;
       circDLLNode *prev = NULL;

     
       while((curr != NULL) && (idx < pos))
       {
           prev = curr;
           curr = curr->getNext();
           idx++;
       }

    
       if(idx == pos)
       {
        
           prev->setNext(node);
           node->setNext(curr);
         
           if(node->getNext() == NULL)
               tail = node;
       }else
       {
           addToTail(val);
       }
   }

}

template

void circDLList:: printList()
{
   if(head == NULL)
       cout<<"Empty list"<    else
   {
       circDLLNode *curr = head;

       while(curr != NULL)
       {
           cout<getVal()<            curr = curr->getNext();
       }
   }
   cout< }

#endif

Answer 1

struct Node
{
    int value;
    struct Node *next;
    struct Node *prev;
};
void insertBegin(struct Node** start, int value)
{
     
    struct Node *last = (*start)->prev;
    struct Node* nnode = new Node;
    nnode->value = value;   
    nnode->next = *start;
    nnode->prev = last;
    last->next = (*start)->prev = nnode;
    *start = nnod
}
  
void insertEnd(struct Node** start, int value)
{
    if(*start == NULL) //if it is empty list
    {
        struct Node* nnode =new Node;
        nnode->value = value;
        nnode->next = nnode->prev = nnode;
        *start = nnode;
       return;
    }
    //if list is not empty
    Node *last = (*start)->prev;
      struct Node* nnode = new Node;
      nnode->value = value;
nnode->next = *start;
    (*start)->prev = nnode;
      nnode->prev = last;
     last->next = new_node;
}
  
void insertbetween(struct Node** start, int value1,
                                      int value2)
{
    struct Node* nnode = new Node;
    nnode->value = value1;
    struct Node *temp = *start;
     while(temp->value != value2)
        temp = temp->next;
    struct Node *next = temp->next;
    temp->next = nnode;
    nnode->prev = temp;
    nnode->next = next;
    next->prev = nnode;
}
  
  
void display(struct Node* start)
{
    struct Node *temp = start;
    while(temp->next != start)
    {
        cout<<temp->value;
        temp = temp->next;
    }