list.c: In function `Delete':
list.c:122: error: request for member `question' in something not a structure or union
list.c:123: error: request for member `answer' in something not a structure or union
list.c:169: error: request for member `question' in something not a structure or union
list.c:170: error: request for member `answer' in something not a structure or union

int Delete (NODEPTR *headPtr, char *target, QUIZ *deletedQuestion)
{
   /*  Node pointers that reference the previous node
       and the current node in the list.               */
   NODEPTR prev = NULL, curr = NULL;
   
   /*  Check to see if the list is empty.  */
   if (IsEmpty (*headPtr))
   {
      /*  Display an appropriate message indicating that
	  deleting from the list was not accomplished
	  because the list is empty.                      */
      fprintf (stderr, "Unable to delete from an empty list.\n\n");
      
      /*  If the list is empty, return the integer value
	  of -1, indicating that the question, char
	  *target, was not successfully deleted from the
	  list.                                           */
      return (-1);
   }
   
   /*  Traverse the list until the target value is found.  */
   
   /*  Initialize the node pointer referencing a previous
       node in the list to NULL.                           */
   prev = NULL;
   
   /*  Set the node pointer referencing a current node to
       the head of the list.                               */
   curr = *headPtr;
   
   /*  First check to see if the question, char *target,
       that we want to delete is stored in the first
       node in the list, because this would require
       *headPtr to be modified.                           */
   if (strcmp (curr -> data.question, target) == 0)
   {
      /*  Copy the contents of the data portion of the
	  node containing the question, char *target,
	  that we want to delete from list into the
	  QUIZ structure, deletedQuestion.              */
      strcpy (curr -> data.question, *deletedQuestion.question);
      strcpy (curr -> data.answer, *deletedQuestion.answer);
      
      /*  If the question, char *target, is stored in the
	  first node in the list, change the head of the
	  list to start at the node pointer referencing
	  the current node's next pointer.                 */
      *headPtr = curr -> next;
      
      /*  Delete and free the memory that was being used
	  to store the question, char *target, in the
	  first node of the list.                         */
      free (curr);
      
      /*  If the question, char *target, was freed and
	  deleted, return the integer value of 1,
	  indicating that the question was successfully
	  deleted from the list.                         */
      return (1);
   }
   /*  Otherwise, traverse through the list to find the
       question, char *target, to be deleted.            */
   else
   {
      /*  Traverse the list if the node pointer
	  referencing the current node in the list is not
	  equal to NULL and the node pointer referencing
	  the current node in the list is not storing the
	  question, char *target, in the data portion of
	  its node.                                        */
      while ((curr != NULL) &&
	     (strcmp (curr -> data.question, target) != 0))
      {
	 /*  Traverse the list.  */
	 prev = curr;
	 curr = curr -> next;
      }
      
      /*  If the node pointer refencing the current node in
	  the list not equal to NULL, then the question,
	  char *target, was found.                           */
      if (curr != NULL)
      {
	 /*  Copy the contents of the data portion of the
	     node containing the question, char *target,
	     that we want to delete from list into the
	     QUIZ structure, deletedQuestion.              */
	 strcpy (curr -> data.question, *deletedQuestion.question);
	 strcpy (curr -> data.answer, *deletedQuestion.answer);
	 
	 /*  Change the next pointer of the previous node,
	     in order to avoid a broken list.               */
	 prev -> next = curr -> next;
	 
	 /*  Delete and free the memory that was being used
	     to store the question, char *target, in this
	     node of the list.                               */
	 free (curr);
	 
	 /*  If the question, char *target, was freed and
	     deleted, return the integer value of 1,
	     indicating that the question was successfully
	     deleted from the list.                         */
	    return (1);
      }
      /*  Otherwise, the question, char *target, was not
	  found in the list.                              */
      else
      {
	 /*  If the question, char *target, was not found
	     in the list, return the integer value of -1,
	     indicating that the question was not
	     successfully deleted from the list.           */
	 return (-1);
      }
   }
}

/* NODEPTR is defined as an alias for the structure of type
   node, so that it can be used within the structure before
   it is completely defined.                              */

typedef struct node * NODEPTR;

/* This struct, typedefed to be of type quiz, is meant to
   store all the data about each question in the quiz that
   will be given to the user.                             */

typedef struct quiz
{
   char question [NUMBEROFQUESTIONCHARACTERS];
   char answer [NUMBEROFANSWERCHARACTERS];
} QUIZ;

/* A NODE is a structure that allows us to build a linked
   list since it has both a data portion and a NODEPTR as
   its members.  The NODEPTR called next is known as the
   link.                                                  */

typedef struct node
{
   QUIZ data;
   NODEPTR next;  /* OR struct node *next; */
} NODE;

curr is defined as a NODEPTR (or rather: struct node *)
deletedQuestion is defined as a QUIZ *

Both curr and deletedQuestion are pointers to structs, but then you do this:

strcpy (curr -> data.question, *deletedQuestion.question);

(*deletedQuestion).question