Deque implementation based on doubly linked list not working - c++

Question

here is my code for deque implementation using doubly linked list. It is not working..can u get me some pointers on where i am going wrong. The pointers are not initialised and the code is getting stuck in the addqatend function.
#include <stdio.h>
#include <conio.h>
#include <iostream>
#include <string.h>
#include<time.h>
#include<math.h>
#include<ctype.h>
#include <malloc.h>
#include <Windows.h>
struct node
{
struct node *prev;
int data;
struct node *next;
};
struct queue
{
struct node *front;
struct node *rear;
};
void initqueue(struct queue *);
void addqatbeg(struct queue *,int);
void addqatend(struct queue *, int);
int delqatbeg(struct queue *);
int delqatend(struct queue *);
void delqueue(struct queue *);
int main()
{
struct queue a;
int i;
system("cls");
initqueue(&a);
addqatbeg(&a,11);
addqatbeg(&a,23);
addqatbeg(&a,-5);
addqatbeg(&a,45);
addqatend(&a,34);
addqatend(&a,78);
i = delqatbeg(&a);
if(i!=NULL)
printf("item deleted from front:%d",i);
i = delqatbeg(&a);
if(i!=NULL)
printf("item deleted from front:%d",i);
i = delqatend(&a);
if(i!=NULL)
printf("item deleted from end:%d",i);
i = delqatend(&a);
if(i!=NULL)
printf("item deleted from end:%d",i);
delqueue(&a);
system("pause");
return 0;
}
//initialise the queue
void initqueue(struct queue *q)
{
q->front = q->rear = NULL;
}
//add at the beginning of the queue
void addqatbeg(struct queue *q,int item)
{
struct node *temp;
temp = (struct node *)malloc(sizeof(struct node));
if(temp == NULL)
printf("queue is full\n");
//temp->data = item;
//temp->link = NULL;
if(q->front == NULL)
{
q->rear = q->front = temp;
q->front->prev = NULL;
q->front->next = NULL;
q->rear->next = NULL;
q->rear->prev = NULL;
return;
}
q->front->data = item;
q->front->next = temp;
q->front = temp;
q->front->prev = q->front;
//q->rear->next = q->front->next;
//q->front->prev = q->rear;
}
//add at the end of the queue
void addqatend(struct queue *q, int item)
{
struct node *temp;
temp = (struct node*)malloc(sizeof(struct node));
if(temp == NULL)
printf("queue is full\n");
if(q->front == NULL)
{
q->rear = q->front = temp;
q->front->prev = NULL;
q->front->next = NULL;
return;
}
while(q->front->next!=NULL)
q->rear = q->front->next;
q->rear->data = item;
q->rear->next =temp;
q->rear = q->rear->next;
q->rear->prev = q->rear;
}
//delete at the beginning of the queue
int delqatbeg(struct queue *q)
{
struct node *temp;
int item;
if(q->front ==NULL)
{
printf("queue is empty:\n");
return NULL;
}
item = q->front->data;
temp = q->front;
q->front = q->front->next;
free(temp);
return item;
}
//delete at the end of the queue
int delqatend(struct queue *q)
{
struct node *temp;
int item;
if(q->rear == NULL)
{
printf("queue is empty\n");
return NULL;
}
item = q->rear->data;
temp = q->rear;
q->rear = q->rear->prev;
free(temp);
return item;
}
//free the nodes
void delqueue(struct queue *q)
{
struct node *temp;
if(q->front == NULL)
return;
while(q->front!=NULL)
{
temp = q->front;
q->front = q->front->next;
free(temp);
}
}

Answer 1

There are various issues here.
#include <stdio.h>
#include <conio.h>
#include <iostream>
#include <string.h>
#include<time.h>
#include<math.h>
#include<ctype.h>
#include <malloc.h>
#include <Windows.h>
Ugh, that's a whole slew of includes. What language are you using? Make up your mind. <iostream> is a C++ header, the rest are C headers. What is <malloc.c>? Usually, malloc should be in <stdlib.h> or <windows.h>. For this example, you just need <stdlib.h> and <stdio.h>.
If I switch on compiler warnings, I get the warnings about comparing and assignig integers to pointers. In delqatend you should return plain 0 as error code, not NULL. likewise here:
i = delqatbeg(&a);
if (i != NULL)
printf("item deleted from front:%d", i);
The NULLshould be 0. (0 is a language representation of the null pointer as well as of null integers, but the macro NULL casts it to (void *), making it a pointer. here' i is an integer.) Also, please print a newline at the end of the string.
temp = (struct node *) malloc(sizeof(struct node));
if (temp == NULL)
printf("queue is full\n");
I like how the queue is full if your job is out of memory, but you shouldn't just print that but do domething else like aborting the process or returning an error code, otherwise you'll do something bad later on in the function to a NULL pointer.
Okay, now to your main problem. Let's look at your function addqatbeg. In the case where the queue is empty you insert the node correctly, although you essentially do the same assignment twice, because q->front and q->end are equal. But you don't assign the data to the new node.
The other case, where there is already a node in the queue, is a mess. You don't isert nodes by jiggling around their data, but by reornagising the queue structure through the pointers. Here's a better addqatbeg:
//add at the beginning of the queue
void addqatbeg(struct queue *q, int item)
{
struct node *temp;
// Create node and check for NULL
temp = (struct node *) malloc(sizeof(struct node));
if (temp == NULL) {
printf("queue is full\n");
return;
}
// Assign data
temp->data = item;
temp->prev = temp->next = NULL;
// Insert node
if (q->front == NULL) {
q->rear = q->front = temp;
} else {
temp->next = q->front;
q->front->prev = temp;
q->front = temp;
}
}
It should be easy to implement addqatend now. The functions addqatend and addqatbeg are totally analogous in your case, bacause you maintain forward and backward pointers. The while loop in your addqatend is superflous and introduces an endless loop: You check q->front, but never update it in your loop.

Answer 2

Look if these functions work for you. Repeating patterns suggest some refactoring in common functions, but try this out.
Addqatbeg:
//add at the beginning of the queue
void addqatbeg(struct queue *q,int item)
{
struct node *temp;
temp = (struct node *)malloc(sizeof(struct node));
if(temp == NULL)
printf("queue is full\n");
if(q->front == NULL)
{
q->rear = q->front = temp;
q->front->data = item;
return;
}
q->front->next = temp;
q->front = q->front->next;
q->front->data = item;
}
Addqatend:
//add at the end of the queue
void addqatend(struct queue *q, int item)
{
struct node *temp;
temp = (struct node *)malloc(sizeof(struct node));
if(temp == NULL)
printf("queue is full\n");
if(q->rear == NULL)
{
q->rear = q->front = temp;
q->rear->data = item;
return;
}
q->rear->prev = temp;
q->rear = q->rear->prev;
q->rear->data = item;
}
Delqatbeg:
//delete at the beginning of the queue
int delqatbeg(struct queue *q)
{
struct node *temp;
int item;
if(q->front == NULL)
{
printf("queue is empty:\n");
return NULL;
}
item = q->front->data;
temp = q->front;
q->front = q->front->prev;
free(temp);
}
return item;
}
Delqatend:
//delete at the beginning of the queue
int delqatend(struct queue *q)
{
struct node *temp;
int item;
if(q->rear == NULL)
{
printf("queue is empty:\n");
return NULL;
}
item = q->rear->data;
temp = q->rear;
q->rear = q->rear->next;
free(temp);
return item;
}