Segmentation Fault in A Doubly Linked List Display Function - c

Question

So I have a program that takes an int for input, and inserts the integer into a doubly linked list where the functions are createQueue, enqueue, dequeue, display, peek, and destroyQueue. I have a main.c and a queue.h file but the problem doesn't lay in there, it's in the queue.c file. The problem is when I pipeline a test12.txt file and print to an output.txt with the following commands, enqueue 0 0 display, I get a segmentation fault. If I run just enqueue 0 0 in the test12.txt file there's no problem, it works just fine. My question is, am I dereferencing temp in display when it points to nothing when I write temp = temp->prev; or is that a valid call and my problem lies in the initialization of my temp node?
queue.c file:
#include "queue.h"
Queue_ptr createQueue() {
Queue_ptr s = (Queue_ptr)malloc(sizeof(Queue));
s->front = NULL;
s->back = NULL;
return s;
}
void enqueue(Queue_ptr s, element e) {
DN_ptr n = (DN_ptr)malloc(sizeof(DLLNode));
n->e = e;
if (s->front == NULL) {
n->next = NULL;
s->front = n;
s->back = n;
}else{
s->back->next = n;
n->prev = s->back;
s->back = n;
}
}
element dequeue(Queue_ptr s) {
DN_ptr temp = s->front->next;
element e = s->front->e;
free(s->front);
s->front = temp;
s->front->next = NULL;
s->front->prev = NULL;
return e;
}
int isEmpty(Queue_ptr s) {
if (s->front == NULL)
return 1;
else
return 0;
}
element peek(Queue_ptr s) {
return s->front->e;
}
void display(Queue_ptr s) {
DN_ptr temp = s->back;
while (temp) {
printf("%d\n", temp->e);
temp = temp->prev;
}
}
void destroyQueue(Queue_ptr s) {
DN_ptr temp = s->front;
DN_ptr next;
while (temp) {
next = temp->next;
free(temp);
temp = next;
}
free(s);
}
queue.h file:
#ifndef queue_h
#define queue_h
#include "stdheader.h"
//Structures
//element is content of a node.
typedef int element;
//_DLLnode is 1 link in a doubly linked list.
struct _DLLNode {
element e;
struct _DLLNode *next;
struct _DLLNode *prev;
};
typedef struct _DLLNode DLLNode;
typedef struct _DLLNode *DN_ptr;
//DLL is a series of links tracked by the head and back of the list.
struct _DLL {
DN_ptr front;
DN_ptr back;
};
typedef struct _DLL Queue;
typedef struct _DLL *Queue_ptr;
Queue_ptr createQueue();
void enqueue(Queue_ptr, element);
element dequeue(Queue_ptr);
int isEmpty(Queue_ptr);
element peek(Queue_ptr);
void display(Queue_ptr);
void destroyQueue(Queue_ptr);
#endif /* queue_h */

Answer 1

You do not set n->prev in enqueue when the queue is empty, neither do you set n->next when the queue is not empty.
dequeue corrupts the queue if it has more than 2 elements, and it crashes if it has only one element.
Here is a corrected version:
void enqueue(Queue_ptr s, element e) {
DN_ptr n = (DN_ptr)malloc(sizeof(DLLNode));
n->e = e;
n->next = NULL;
if (s->front == NULL) {
n->prev = NULL;
s->front = n;
s->back = n;
} else {
s->back->next = n;
n->prev = s->back;
s->back = n;
}
}
element dequeue(Queue_ptr s) {
DN_ptr temp = s->front->next;
element e = s->front->e;
free(s->front);
s->front = temp;
if (temp) {
temp->prev = NULL;
} else {
s->back = NULL;
}
return e;
}