Printing and Deleting queue in C

Question

I'm trying to write a program that enqueue, dequeue, delete a chosen number and print the list. I have problems with the dequeue that i think is because of the menu part when you write a number, I've tried to fix it but the it removes the last number and not the first. The print shows the wrong number and when I tried to solve that problem I got the same problem as I had in dequeue. It's sometinhg wrong in delete but i cant figure it out.

I appreciate all the help i can get

edit: I've changed it a lot and now everything else works except delete. I want delete to find the number i enter and delete it.

queue.c

#include <stdio.h>
#include <stdlib.h>
#include<conio.h>

struct node
{
    int info;
    struct node *ptr;
    int next;
}*first, *last, *temp, *first1;




void enq(int data);
void deq();
void empty();
void display();
void create();
void delete_queue();

int count = 0;

void main()
{
    int no, ch;

    printf("\n 1 - Enqueue");
    printf("\n 2 - Dequeue");
    printf("\n 3 - Delete");    
    printf("\n 4 - Display");
    printf("\n 5 - Exit");
    create();
    while (1)
    {
        printf("\n Enter choice : ");
        scanf_s("%d", &ch);
        switch (ch)
        {
        case 1:
            printf("Enter data : ");
            scanf_s("%d", &no);
            enq(no);
            break;
        case 2:
            deq();
            break;
        case 3:
            printf("Enter data : ");
            scanf_s("%d", &no);
            delete_queue(no);   
        case 4:
            display();
            break;
        case 5:
            exit(0);

        default:
            printf("Wrong choice, Please enter correct choice  ");
            break;
        }
    }
}


void create()
{
    first = last = NULL;
}


void enq(int data)
{
    if (last == NULL)
    {
        last = (struct node *)malloc(1 * sizeof(struct node));
        last->ptr = NULL;
        last->info = data;
        first = last;
    }
    else
    {
        temp = (struct node *)malloc(1 * sizeof(struct node));
        last->ptr = temp;
        temp->info = data;
        temp->ptr = NULL;

        last = temp;
    }
    count++;
}


void display()
{
    first1 = first;

    if ((first1 == NULL) && (last == NULL))
    {
        printf("Queue is empty");
        return;
    }
    while (first1 != last)
    {
        printf("%d ", first1->info);
        first1 = first1->ptr;
    }
    if (first1 == last)
        printf("%d", first1->info);
}

void deq()
{
    first1 = first;

    if (first1 == NULL)
    {
        printf("\n Error: Trying to display elements from empty queue");
        return;
    }
    else
        if (first1->ptr != NULL)
        {
            first1 = first1->ptr;
            printf("\n Dequed value : %d", first->info);
            free(first);
            first = first1;
        }
        else
        {
            printf("\n Dequed value : %d", first->info);
            free(first);
            first = NULL;
            last = NULL;
        }
    count--;
}



void delete_queue()
{
    int retval = -1;
    if (first)
    {
        struct node *temp = first;
        first = first->next;
        if (!first) { last = first; }
        retval = temp->next;
        free(temp);
    }
    return retval;
}
void empty()
{
    if ((first == NULL) && (last == NULL))
        printf("\n Queue empty");
    else
        printf("Queue not empty");
}

Answer 1

Let me start with a few points of advice about design and style:

I do not recommend this:

typedef struct node {
    int data;
    struct node *next;
} node;

you are typedefing struct node to node. while it is not illegal, it is confusing. I would recommend

typedef struct _node {
    int data;
    struct _node *next;
} node;

Additionally, I do not recommend use of global variable with static storage class to keep track of your queue, instead you should create a queue in your main. Use global variables only when you have compelling reasons to do so.

Do remember that when you get rid of your global variable, you will need to rewrite your enqueue dequeue delete etc... functions to take in a queue_c * as parameter (because it wont have access to queueref any more)

Now for the reason that your code is not working properly and @Weather Vane alluded to:

you have a big problem in your delete function.

int delete(int data) 
{
    int result = 0;

    node *curr_ptr; //pointer just created and not initialized
    node *prev_ptr; //not initialized
    node *temp_ptr; //not initialized

    while (curr_ptr != NULL) 
    //curr_ptr was just created, where is it pointing? fatal error here
    {
    //inside this block lets imagine curr_ptr is pointing to a valid
    //node in the global queue

        if (curr_ptr->data == data) 
        {
            result = 1;
            if (curr_ptr->next != NULL) 
            {
                temp_ptr = curr_ptr;  
                //both pointers point to the same thing
                destroy_node(temp_ptr); 
                //now you just destroyed both nodes
                prev_ptr->next = curr_ptr->next;
                //the first time this block runs prev_ptr is uninitialized
                //so prev_ptr->next will most likely seg fault
                //this happens for example if you call this function
                //for the first time with a long queue    
            }
            else 
            {
                temp_ptr = curr_ptr;
                queueref.last = prev_ptr; 
                prev_ptr->next = NULL;
                destroy_node(temp_ptr); 
                //again you are destroying both curr_ptr and temp_ptr
            }
        }
        curr_ptr = curr_ptr->next;   
        prev_ptr = prev_ptr->next;
        return result;
    }
}

Perhaps it would be better if you think edge cases very carefully and rethink some of the logic from scratch. (test edge cases as you go)