Below is an example function that might use the function RemoveDNode
that passes its pointer "by value".
The user is aware that after calling RemoveDNode the pointer to the
node removed has to be reset. The user is also aware that if he/she
calls RemoveDNode on the first node of the list, they must first reset
the pointer to the beginning of the list.
    
Consider the following list of faculty where "faculty" is the pointer
to the list and the list contains 5 nodes.

   faculty               
     |                  
     v                  
 Rodger  <--> Kedem  <-->  Astrachan  <--> Ellis <--> Chase 


void RemoveEveryOtherNode(DNode * & list)
// removes every other node from the list starting with the first one.
{
   DNode * temp = list;
   DNode * prev = NULL;
   if (list != NULL)
   {
       list = list->next;       // reset list to second node
       RemoveDNode(temp);       // removes first DNode from list
       temp = list;             // must reset temp value
       while (temp != NULL && temp->next != NULL)  // there is another DNode
       {                                           // to remove
            prev = temp;                            // DNode before
	    temp = prev->next;                      // DNode to remove
	    RemoveDNode(temp);                      // remove DNode
	    temp = prev->next;                      // reset temp to next DNode
       }	    
}

We'll call RemoveEveryOtherNode(faculty);
Note that faculty is passed by reference and is now called list
inside the function. We want to reset 'list' to point to the second
DNode in the list, the beginning of the new list, but cannot use
'list' to traverse the whole list since that means 'faculty' would no
longer point to the beginning of the new list.

Right before RemoveDNode is called the first time the list looks
like the following (we have reset list to the beginning of the new list):

 temp          list
  |             |                  
  v             v                  
 Rodger  <--> Kedem  <-->  Astrachan  <--> Ellis <--> Chase 

 After calling RemoveDNode and resetting temp, the list looks like:

     list
      |                  
      v                  
     Kedem  <-->  Astrachan  <--> Ellis <--> Chase 
      ^
      |
     temp

Right before calling RemoveDNode the first time in the while loop
the list looks like:

     list
      |                  
      v                  
     Kedem  <-->  Astrachan  <--> Ellis <--> Chase 
      ^              ^
      |              |   
     prev          temp

After the RemoveDNode call AND the next statement (resetting temp)
the list looks like:

     list
      |                  
      v                  
     Kedem  <-->  Ellis <--> Chase 
      ^              ^
      |              |   
     prev          temp


At the end of this function the list looks like:
     
     list         prev
      |             |     
      v             v     
     Kedem  <-->  Ellis     temp = NULL

Every other node from the original list (starting with the first node)
has been removed.