Data Structure using C
Interview Questions with Answers

21. What is a stack? How is it implemented in C using arrays?

Answer:

A stack is a linear data structure that follows the Last In First Out (LIFO) principle.

 Operations:

• push() – Insert at the top
• pop() – Remove from the top
• peek() – View top element 

Array Implementation

#include <stdio.h>
#define SIZE 100
int stack[SIZE], top = -1;
void push(int val) {
    if (top == SIZE - 1) {
        printf("Stack Overflow\n");
        return;
    }
    stack[++top] = val;
}
int pop() {
    if (top == -1) {
        printf("Stack Underflow\n");
        return -1;
    }
    return stack[top--];
}

22. What is the difference between stack and heap memory?

Answer:

23. Write a C program to implement stack using linked list.

Answer:

#include <stdio.h>
#include <stdlib.h>
struct Node {
int data;
struct Node* next;
};
struct Node* top = NULL;
void push(int val) {
struct Node* newNode = (struct Node*) malloc(sizeof(struct Node));
newNode->data = val;
newNode->next = top;
top = newNode;
}
int pop() {
if (top == NULL) {
printf("Stack Underflow\n");
return -1;
}
int val = top->data;
struct Node* temp = top;
top = top->next;
free(temp);
return val;
}
void display() {
struct Node* temp = top;
while (temp) {
printf("%d -> ", temp->data);
temp = temp->next;
}
printf("NULL\n");
}
int main() {
push(10); push(20); push(30);
display();         // 30 -> 20 -> 10 -> NULL
pop(); display();  // 20 -> 10 -> NULL
return 0;
}

24. What is stack overflow and how can you prevent it?

Answer:

A stack overflow occurs when the stack exceeds its size limit, either:

• In array-based stack: inserting more than its capacity
• In recursion: too many function calls without returning 

Prevention:

• In arrays: Check top == SIZE – 1 before push()
• In recursion: Ensure base case exists and avoid infinite recursion
• Use dynamic stack (linked list) when size is unknown

25. Write a program to convert infix expression to postfix using stack.

Answer:

#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <string.h>
#define SIZE 100
char stack[SIZE];
int top = -1;
int precedence(char op) {
if (op == '+' || op == '-') return 1;
if (op == '*' || op == '/') return 2;
return 0;
}
void push(char c) { stack[++top] = c; }
char pop() { return stack[top--]; }
char peek() { return stack[top]; }
void infixToPostfix(char* expr) {
for (int i = 0; expr[i]; i++) {
char ch = expr[i];
if (isalnum(ch)) printf("%c", ch);
else if (ch == '(') push(ch);
else if (ch == ')') {
while (peek() != '(') printf("%c", pop());
pop(); // remove '('
}
else {
while (top != -1 && precedence(ch) <= precedence(peek()))
printf("%c", pop());
push(ch);
}
}
while (top != -1) printf("%c", pop());
}
int main() {
char expr[] = "a+b*(c-d)";
printf("Postfix: ");
infixToPostfix(expr);  // Output: abcd-*+
return 0;
}

26. How to evaluate postfix expression using a stack in C?

Answer:

#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#define SIZE 100
int stack[SIZE], top = -1;
void push(int val) { stack[++top] = val; }
int pop() { return stack[top--]; }
int evaluate(char* exp) {
for (int i = 0; exp[i]; i++) {
char ch = exp[i];
if (isdigit(ch)) push(ch - '0');
else {
int b = pop(), a = pop();
switch (ch) {
case '+': push(a + b); break;
case '-': push(a - b); break;
case '*': push(a * b); break;
case '/': push(a / b); break;
}
}
}
return pop();
}
int main() {
char exp[] = "53*2+";
printf("Result: %d\n", evaluate(exp));  // Output: 17
return 0;
}

27. Explain real-life applications of stack data structure.

Answer:

• Undo/Redo functionality (text editors)
• Function call management (call stack)
• Balanced parentheses checker
• Expression evaluation (infix → postfix)
• Backtracking algorithms (maze solving, recursion)
• Browser history navigation

28. What are the basic operations of a stack (push, pop, peek) in C?

Answer:

#define SIZE 100
int stack[SIZE], top = -1;
void push(int val) {
if (top == SIZE - 1) {
printf("Stack Overflow\n"); return;
}
stack[++top] = val;
}
int pop() {
if (top == -1) {
printf("Stack Underflow\n"); return -1;
}
return stack[top--];
}
int peek() {
if (top == -1) return -1;
return stack[top];
}

29. How can you reverse a string using stack in C?

Answer:

#include <stdio.h>
#include <string.h>
#define SIZE 100
char stack[SIZE];
int top = -1;
void push(char c) { stack[++top] = c; }
char pop() { return stack[top--]; }
int main() {
char str[] = "Hello";
int len = strlen(str);
for (int i = 0; i < len; i++) push(str[i]);
for (int i = 0; i < len; i++) str[i] = pop();
printf("Reversed: %s\n", str);  // Output: olleH
return 0;
}

30. How do you check for balanced parentheses using stack in C?

Answer:

#include <stdio.h>
#define SIZE 100
char stack[SIZE];
int top = -1;
void push(char c) { stack[++top] = c; }
char pop() {
if (top == -1) return '\0';
return stack[top--];
}
int isBalanced(char* exp) {
for (int i = 0; exp[i]; i++) {
if (exp[i] == '(' || exp[i] == '{' || exp[i] == '[')
push(exp[i]);
else if (exp[i] == ')' || exp[i] == '}' || exp[i] == ']') {
char open = pop();
if ((exp[i] == ')' && open != '(') ||
(exp[i] == '}' && open != '{') ||
(exp[i] == ']' && open != '['))
return 0;
}
}
return top == -1;
}
int main() {
char exp[] = "{(a+b)*[c-d]}";
if (isBalanced(exp))
printf("Balanced\n");
else
printf("Not Balanced\n");
return 0;
}

31. What is a queue? How is it implemented in C using arrays?

Answer:

A queue is a linear data structure that follows the FIFO (First In First Out) principle. 

Basic Operations:

• enqueue() – Add element at the rear
• dequeue() – Remove element from the front

Array Implementation

#include <stdio.h>
#define SIZE 5
int queue[SIZE];
int front = -1, rear = -1;
void enqueue(int val) {
if (rear == SIZE - 1) {
printf("Queue Overflow\n");
return;
}
if (front == -1) front = 0;
queue[++rear] = val;
}
int dequeue() {
if (front == -1 || front > rear) {
printf("Queue Underflow\n");
return -1;
}
return queue[front++];
}

32. Write a C program to implement circular queue.

Answer:

#include <stdio.h>
#define SIZE 5
int queue[SIZE];
int front = -1, rear = -1;
int isFull() { return (rear + 1) % SIZE == front; }
int isEmpty() { return front == -1; }
void enqueue(int val) {
if (isFull()) {
printf("Queue Overflow\n");
return;
}
if (isEmpty()) front = rear = 0;
else rear = (rear + 1) % SIZE;
queue[rear] = val;
}
int dequeue() {
if (isEmpty()) {
printf("Queue Underflow\n");
return -1;
}
int val = queue[front];
if (front == rear) front = rear = -1;
else front = (front + 1) % SIZE;
return val;
}
void display() {
if (isEmpty()) {
printf("Queue is Empty\n");
return;
}
printf("Queue: ");
int i = front;
do {
printf("%d ", queue[i]);
i = (i + 1) % SIZE;
} while (i != (rear + 1) % SIZE);
printf("\n");
}
int main() {
enqueue(10); enqueue(20); enqueue(30); enqueue(40);
dequeue(); dequeue();
enqueue(50); enqueue(60);
display();  // Expected: 30 40 50 60
return 0;
}

33. How is a queue implemented using linked list?

Answer:

#include <stdio.h>
#include <stdlib.h>
struct Node {
int data;
struct Node* next;
};
struct Node *front = NULL, *rear = NULL;
void enqueue(int val) {
struct Node* newNode = (struct Node*) malloc(sizeof(struct Node));
newNode->data = val;
newNode->next = NULL;
if (rear == NULL) front = rear = newNode;
else {
rear->next = newNode;
rear = newNode;
}
}
int dequeue() {
if (front == NULL) {
printf("Queue Underflow\n");
return -1;
}
int val = front->data;
struct Node* temp = front;
front = front->next;
if (front == NULL) rear = NULL;
free(temp);
return val;
}
void display() {
struct Node* temp = front;
while (temp) {
printf("%d -> ", temp->data);
temp = temp->next;
}
printf("NULL\n");
}

34. What is the difference between queue and stack?

Answer:

35. What is a dequeue (double-ended queue)?

Answer:

A deque (double-ended queue) is a linear data structure in which insertion and deletion can be done from both front and rear ends. 

Types of Deques:

• Input-restricted: Insertion only at rear
• Output-restricted: Deletion only from front 

Use Cases:

• Task scheduling
• Palindrome checking
• Sliding window problems in algorithms

36. Write a C program for priority queue implementation.

Answer:

#include <stdio.h>
#define SIZE 10
struct PQ {
int data;
int priority;
} pq[SIZE];
int count = 0;
void insert(int data, int priority) {
if (count == SIZE) {
printf("Priority Queue Overflow\n");
return;
}
int i = count - 1;
while (i >= 0 && pq[i].priority > priority) {
pq[i + 1] = pq[i];
i--;
}
pq[i + 1].data = data;
pq[i + 1].priority = priority;
count++;
}
int delete() {
if (count == 0) {
printf("Priority Queue Underflow\n");
return -1;
}
return pq[--count].data;
}
void display() {
for (int i = 0; i < count; i++)
printf("(%d, P%d) ", pq[i].data, pq[i].priority);
printf("\n");
}
int main() {
insert(30, 2);
insert(10, 1);
insert(20, 3);
display();      // Output: (10, P1) (30, P2) (20, P3)
delete(); display();
return 0;
}

37. What is queue overflow and underflow?

Answer:

• Queue Overflow: Occurs when trying to enqueue an element in a full queue.
• Queue Underflow: Occurs when trying to dequeue from an empty queue.

Prevention:

• Check rear == SIZE – 1 for array-based queue.
• Use circular queues to optimize space.

38. How do you simulate a real-world task scheduler using queue in C?

Answer:

Use a queue to simulate task scheduling, where tasks are added and executed in order. 

Example

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
struct Task {
char name[20];
struct Task* next;
};
struct Task *front = NULL, *rear = NULL;
void addTask(char name[]) {
struct Task* newTask = (struct Task*) malloc(sizeof(struct Task));
strcpy(newTask->name, name);
newTask->next = NULL;
if (rear == NULL) front = rear = newTask;
else {
rear->next = newTask;
rear = newTask;
}
}
void runTask() {
if (front == NULL) {
printf("No tasks to run\n");
return;
}
printf("Running task: %s\n", front->name);
struct Task* temp = front;
front = front->next;
free(temp);
if (front == NULL) rear = NULL;
}
int main() {
addTask("Compile Code");
addTask("Run Tests");
addTask("Deploy App");
runTask(); runTask(); runTask();
return 0;
}

39. What is the difference between linear queue and circular queue?

Answer:

40. What are some real-life applications of queues?

Answer:

• CPU and task scheduling
• Printer spooling
• Network routers and packets
• Customer service systems
• Breadth-first search (BFS)
• Order processing systems
• Operating system I/O management