/*    CS 4320 SOFTWARE TESTING AND QUALITY ASSURANCE 

Consider a single-linked list of character elements, for example: 

    c -> a -> f -> r -> q

  The goal is a function which reverses all of the pointers, for example: 

    c <- a <- f <- r <- q

  The function should return a pointer to the last node in the list (and this node 
  is effectively the new head of the list). An initial call would be: 
          
  p = reverse(p);

  For each of the following solutions, CIRCLE CORRECT or INCORRECT. 
  If a solution is INCORRECT, then state the result with a picture of the list
  and a printout.
*/
#include <stdio.h>
#include <stdlib.h>
typedef struct node *node_ptr;
struct node {
  char element;
  node_ptr next;    
};
node_ptr reverse1(node_ptr p) {         // CORRECT  /  INCORRECT
  node_ptr temp, cur, new, nextone;
  if (p != NULL) {
    cur = p;
    while (p->next != NULL) {
      temp = p->next;
      nextone = temp->next;
      new = cur;
      cur->next = new;
      p = nextone;
    }
    return cur; 
  }
  else return NULL;
} 

node_ptr reverse2(node_ptr p) {         // CORRECT  /  INCORRECT
  node_ptr prev_ptr = NULL;
  node_ptr next_ptr;
  while (p) {
    next_ptr = p->next;
    p->next = prev_ptr;
    prev_ptr = p;
    p = next_ptr;
  }
  return prev_ptr;
}

node_ptr reverse3(node_ptr p) {         // CORRECT  /  INCORRECT
  node_ptr t1;
  node_ptr t2 = NULL;
  while (p->next->next != NULL) {
    t1 = p;
    p = p->next;
    t1->next = t2;
    t2 = t1;
  }
  return t1;
}

node_ptr reverse4(node_ptr p) {         // CORRECT  /  INCORRECT
  node_ptr w, t;
  if (p == NULL) return NULL;
  w = p;
  while (w->next != NULL) {
    t = w->next;
    w->next = t->next;
    t->next = p;
    p = t;
  }
  return p;
}

node_ptr reverse5(node_ptr p) {         // CORRECT  /  INCORRECT
  node_ptr q, r, t;
  t = p;
  while (p->next != NULL) {
    q = p->next;
    r = q->next;
    q->next= p;
    p = q;
  }
  t->next = NULL;
  return p;
}