sll.c

Go to the documentation of this file.

/*
** Sll.c - Package to manage singly linked lists.
** ---------------------------------------------------------------
**
** remarks:
** ---------------------------------------------------------------
** Functionality:
** This is a general package for generic handling of singly linked
** lists.  It is generic in the sense that it performs the basic
** operations on singly linked lists (add at the top, add at the
** end, etc.).  To use it adequately, it is required that the first 
** field of a list element be a pointer to the next element in the 
** list.  As usual, this field is null for the last element of the 
** list.
**
** The generic structure for a list element is shown below:
**
** typedef struct relaxsll {
** struct relaxsll    *next;
** } RSll;
**
**
** List head:
** All the functions in this package receive the head of the list 
** as their first argument.  The head works like a handle to the 
** list, which is used to get a hold to it.
** In the operators of this package, the head of the list is always
** returned as the function value.  This is done because there is 
** always the possibility that the head might change in each 
** operation.
**
** ---------------------------------------------------------------
**
** entry pts:
** ---------------------------------------------------------------
**
** RSll   *RSllAddTop( RSll *head, RSll *elem )
**
**                head      - head of list                   (in)
**                elem      - element to add                 (in)
**
**            This function inserts an element at the top of a list.
**            If the list is empty, which is assumed the case if
**            head is null, the function returns elem as the head.
**
**      ---------------------------------------------------------------
**
**       RSll   *RSllRmvTop( RSll *head )
**
**                head      - head of list                   (in)
**
**            This function removes the element at the top of a list
**            and returns the next element (which can be null) as the
**            new head.
**            If the list is empty, which is assumed the case if
**            head is null, it does not do anything.
**
**      ---------------------------------------------------------------
**
**      RSll   *RSllAddEnd( RSll *head, RSll *elem )
**
**                head      - head of list                   (in)
**                elem      - element to add                 (in)
**
**            This function inserts an element at the end of a list.
**            If the list is empty (null head), elem is returned 
**            as the new head.
**
**      ---------------------------------------------------------------
**
**       RSll   *RSllAddAft( RSll *head, RSll *before, RSll *elem )
**
**                head      - head of list                   (in)
**                before    - elem before the new one        (in)
**                elem      - element to add                 (in)
**
**            This function inserts an element after a given element
**            of a list.
**            If the list is empty (null head), elem is returned 
**            as the new head and the before parameter is
**            disregarded.
**            If the list is not empty, nothing will be done if the 
**            before element is not found.
**
**      ---------------------------------------------------------------
**
**       RSll   *RSllAddBef( RSll *head, RSll *after, RSll *elem )
**
**                head      - head of list                   (in)
**                after     - elem after the new one         (in)
**                elem      - element to add                 (in)
**
**            This function inserts an element before a given element
**            of a list.
**            If the list is empty (null head), elem is returned 
**            as the new head and the after parameter is
**            disregarded.
**            If the list is not empty, nothing will be done if the 
**            after element is not found.
**
**      ---------------------------------------------------------------
**
**      RSll    *RSllRmvElm( RSll *head, RSll *elem )
**
**                head      - head of list                   (in)
**                elem      - element to remove              (in)
**
**            This function removes an element of a list.
**            If the list is empty (null head), nothing will be 
**            done.
**            If the element to remove is also the head, the next
**            element is returned as the new head, which can also
**            be null.
**            If the given element does not belong to the list,
**            nothing will be done.
**
**      ---------------------------------------------------------------
**
**      Version:      0-001
**
**      Created:    16-Aug-93    Luiz F. Martha
**
**      Modified:    13-Jan-06    Juan Pablo Ibañez                                 
**        Modificados os nomes das funcões acrescentando uma R (relax)
**        no inicio. Modificado o nome da estrutura sll para relaxsll,
**        e o tipo Sll para RSll.
*/

/*
**      ---------------------------------------------------------------
**      Global variables and symbols
*/
#include "sll.h"

/*
**      ---------------------------------------------------------------
**      Local variables and symbols: (none)
*/


/*
**      ---------------------------------------------------------------
**      Private functions: (none)
*/


/*
**      ---------------------------------------------------------------
**      Entry points begin here:
*/

/*=========================  RSllAddTop  =========================*/

RSll *RSllAddTop( RSll *head, RSll *elem )
{
 elem->next = head;

 return( elem );
}


/*=========================  RSllRmvTop  =========================*/

RSll *RSllRmvTop( RSll *head )
{
 if( head == 0L )
 {
  return( 0L );
 }
 else
 {
  return( head->next );
 }
}


/*=========================  RSllAddEnd  =========================*/

RSll *RSllAddEnd( RSll *head, RSll *elem )
{
 RSll *curr;

 elem->next = 0L;

 if( head == 0L )
 {
  return( elem );
 }
 else
 {
  curr = head;
  while( curr->next != 0L )
  {
   curr = curr->next;
  }
  curr->next = elem;
 }

 return( head );
}


/*=========================  RSllAddAft  =========================*/

RSll *RSllAddAft( RSll *head, RSll *before, RSll *elem )
{
 RSll *curr;

 if( head == 0L)
 {
  elem->next = 0L;
  return( elem );
 }

 curr = head;
 while( (curr != before) && (curr != 0L) )
 {
  curr = curr->next;
 }

 if( curr != 0L )
 {
  elem->next = curr->next;
  curr->next = elem;
 }

 return( head );
}


/*=========================  RSllAddBef  =========================*/

RSll *RSllAddBef( RSll *head, RSll *after, RSll *elem )
{
 RSll *curr;

 if( head == 0L)
 {
  elem->next = 0L;
  return( elem );
 }

 if( after == head )
 {
  elem->next = head;
  return( elem );
 }

 curr = head;
 while( (curr->next != 0L) && (curr->next != after) )
 {
  curr = curr->next;
 }

 if( curr->next != 0L )
 {
  elem->next = curr->next;
  curr->next = elem;
 }

 return( head );
}


/*=========================  RSllRmvElm  =========================*/

RSll *RSllRmvElm( RSll *head, RSll *elem )
{
 RSll *prev;

 if( head == 0L ) return( 0L );

 if( head == elem )
 {
  head = elem->next;
 }
 else
 {
  prev = head;
  while( ( prev->next != elem ) && ( prev->next != 0L ) )
  {
   prev = prev->next;
  }

  if( prev->next != 0L )
  {
   prev->next = elem->next;
  }
 }

 return( head );
}

---