#include        "genHTML.h"

/* Doubly-Linked Lists */

/* Algorithms */

/* Insertion Into a Sorted Doubly-Linked List */

NODE *doubleInsert(NODE *ListHeader, int NewYear)
{
   NODE *newNode, *nodeN, *gonnaBeNext, *gonnaBePrev;

   /* test for duplicate */

   for (nodeN = ListHeader; nodeN != NULL; nodeN=nodeN->Next) {
       if (NewYear == nodeN->Year)
           return ListHeader;
       }

   /* Allocate a new node */

   newNode = (NODE *) malloc(sizeof(NODE));
   if (newNode == NULL)
   {
      perror("Error - Out of memory.\n");
      exit(1);
   }

   /* Fill in node information */

   newNode->Year = NewYear;

   gonnaBeNext = ListHeader;

   if (ListHeader == NULL || NewYear <= ListHeader->Year)
   {
      newNode->Prev = NULL;
      newNode->Next = gonnaBeNext;

      if (gonnaBeNext != NULL)
         gonnaBeNext->Prev = newNode;

      return newNode;
   }
   else
   {
      while (gonnaBeNext != NULL && newNode->Year > gonnaBeNext->Year)
      {
         gonnaBePrev = gonnaBeNext;
         gonnaBeNext = gonnaBeNext->Next;
      }

      gonnaBePrev->Next = newNode;
      newNode->Prev = gonnaBePrev;
      newNode->Next = gonnaBeNext;

      if (gonnaBeNext != NULL)
         gonnaBeNext->Prev = newNode;

      return ListHeader;
   }
}

/* Deletion From a Sorted Doubly-Linked List */

NODE *doubleDelete(NODE *ListHeader, int DeleteYear)
{
   NODE *P, *T, *S;

   P = ListHeader;

   if (P != NULL && P->Year == DeleteYear)
   {
      T = P->Next;
      free(P);

      if (T != NULL)
         T->Prev = NULL;

      return T;
   }
   else
   {
      while (P != NULL && P->Year < DeleteYear)
      {
         T = P;
         P = P->Next;
      }

      if (P == NULL || P->Year > DeleteYear)
         printf("Error - key %d not found in list.\n", DeleteYear);
      else
      {
         S = P->Next;
         T->Next = S;
         free(P);

         if (S != NULL)
            S->Prev = T;

         return ListHeader;
      }
   }
}