I have initialised two stacks using a structure with which I am creating a queue. But the stack is not able to store the values which is why enqueue or dequeue operations are not working properly. Here is the code:

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

struct stack{
    int top;
    int size;
    int *s;
};

int isfull(struct stack *st){
    if(st->top==st->size-1){
        return 1;
    }
    return 0;
}

int isempty(struct stack *st){
    if(st->top==-1){
        return 1;
    }
    return 0;
}

void push(struct stack *st,int x){
    if(isfull(st)){
        printf("FULL!!\n");
    }
    else{
        st->top  ;
        st->s[st->top]=x;
    }
}

int pop(struct stack *st){
    int x=-1;
    if(isempty(st)){
        printf("EMPTY!!\n");
    }
    else{
        x=st->s[st->top];
        st->top--;
    }
    return x;
}

void enqueue(struct stack s1,int x){
    push(&s1,x);
}

int dequeue(struct stack s1,struct stack s2){
    int x=-1;
    if(isempty(&s2)){
        if(isempty(&s1)){
            printf("QUEUE IS EMPTY!!\n");
            return x;
        }
        else{
            while(!isempty(&s1)){
                push(&s2,pop(&s1));
            }
        }
    }
    return pop(&s2);
}

void display(struct stack st){
    int i;
    for(i=0;i<=st.top;i  ){
        printf("%d",st.s[i]);
    }
}

int main(){
    int n,choice;
    struct stack s1,s2;
    printf("ENTER SIZE OF QUEUE:");
    scanf("%d",&n);
    s1.size=n;
    s2.size=n;
    s1.top=-1;
    s2.top=-1;
    s1.s=(int *)malloc(s1.size*sizeof(int));
    s2.s=(int *)malloc(s2.size*sizeof(int));
    while(1){
        printf("1.ENQUEUE\n");
        printf("2.DEQUEUE\n");
        printf("3.DISPLAY\n");
        printf("4.EXIT\n");
        printf("ENTER YOUR CHOICE:");
        scanf("%d",&choice);
        switch(choice){
            case(1):
                int x;
                printf("ENTER DATA:");
                scanf("%d",&x);
                enqueue(s1,x);
                break;
            case(2):
                int m;
                m=dequeue(s1,s2);
                printf("ELEMENT DELETED IS:%d\n",m);
                break;
            case(3):
                display(s2);
                break;
            case(4):
                exit(0);
        }
    }
    return 0;
}

What is the error? I think there might be an issue with passing the values to the function.

CodePudding user response：

The main issue is that the enqueue and dequeue don't take pointers as arguments, but struct stack. This means the function gets a copy of the given struct, and that the pointer you pass to push and pop (like &s1) is pointing to that local structure, not to the one in main. By consequence any update to the top member of that stack will not be seen by the caller.

I would suggest to:

• Consistently pass pointers to struct typed arguments. This was well done for the push and pop functions, and there is no reason why it should not be done the same way for enqueue and dequeue functions.

• Define a struct queue so that you abstract a bit that there are two stacks involved and don't have to pass both of them as argument to dequeue.

• Create separate functions for:

  • creating a new stack
  • displaying a stack
  • creating a new queue
  • displaying a queue
  • checking if a queue is empty

Here is how your code would then look:

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

struct stack {
    int top;
    int size;
    int *s;
};

struct stack* newstack(int size) {
    struct stack *s = malloc(sizeof(struct stack));
    s->size = size;
    s->s = malloc(size*sizeof(int));
    s->top = -1;
    return s;
}

int isfull(struct stack *st) {
    return st->top == st->size - 1;
}

int isempty(struct stack *st) {
    return st->top == -1;
}

void push(struct stack *st, int x) {
    if (isfull(st)){
        printf("Full!\n");
    } else {
        st->top  ;
        st->s[st->top] = x;
    }
}

int pop(struct stack *st) {
    int x = -1;
    if (isempty(st)){
        printf("Empty!\n");
    } else {
        x = st->s[st->top];
        st->top--;
    }
    return x;
}

void displaystack(struct stack *st) {
    for(int i = 0; i <= st->top; i  ) {
        printf("%d ", st->s[i]);
    }
}

struct queue {
    struct stack *s1;
    struct stack *s2;
};

struct queue* newqueue(int size) {
    struct queue *q = malloc(sizeof(struct queue));
    q->s1 = newstack(size);
    q->s2 = newstack(size);
    return q;
}

int isemptyqueue(struct queue *q) {
    return isempty(q->s1) && isempty(q->s2);
}

void enqueue(struct queue *q, int x) {
    push(q->s1, x);
}

int dequeue(struct queue *q) {
    int x = -1;
    if (isemptyqueue(q)) {
        printf("Queue is empty!\n");
        return -1;
    }
    if (isempty(q->s2)) {
        while (!isempty(q->s1)) {
            push(q->s2, pop(q->s1));
        }
    }
    return pop(q->s2);
}

void displayqueue(struct queue *q) {
    displaystack(q->s1);
    printf("| ");
    displaystack(q->s2);
    printf("\n");
}


int main() {
    int n, choice, x, m;
    printf("Enter the size of the queue: ");
    scanf("%d", &n);
    struct queue *q = newqueue(n);
    while (choice != 4) {
        printf("1. Enqueue\n");
        printf("2. Dequeue\n");
        printf("3. Display\n");
        printf("4. Exit\n");
        printf("Enter your choice: ");
        scanf("%d", &choice);
        switch (choice) {
        case 1:
            printf("Enter data: ");
            scanf("%d", &x);
            enqueue(q, x);
            break;
        case 2:
            m = dequeue(q);
            printf("The deleted element is: %d\n", m);
            break;
        case 3:
            displayqueue(q);
            break;
        }
    }
    return 0;
}