Pop Using Linked List Node in DSA C - Build from Scratch

Pop Using Linked List Node

📖 Scenario: Imagine you have a stack of books represented as a linked list. You want to remove the top book from the stack and see which book was removed.

🎯 Goal: You will create a linked list representing a stack of books, then write code to remove (pop) the top book from the stack and print the remaining books.

📋 What You'll Learn

Create a linked list node structure with an integer data and a pointer to the next node called next.

Create a linked list with three nodes containing the values 10, 20, and 30, where 30 is the top of the stack.

Write a function called pop that removes the top node from the linked list and returns its value.

Print the linked list after popping the top node to show the remaining stack.

💡 Why This Matters

🌍 Real World

Stacks are used in many real-world applications like undo features in text editors, browser history, and expression evaluation.

💼 Career

Understanding linked list operations like pop is essential for software development roles involving data structures, memory management, and algorithm design.

1

Create the linked list nodes

Define a struct Node with an int data and a struct Node* next. Then create three nodes named node1, node2, and node3 with data 10, 20, and 30 respectively. Link them so that node3 points to node2, and node2 points to node1. Set head to node3.

DSA C

# Define struct Node and create three linked nodes
// Your code here

Hint

Remember to use malloc to create nodes and link them by setting the next pointer.

2

Create the pop function

Write a function called pop that takes a pointer to the pointer of the head node (struct Node** head). The function should remove the top node from the linked list, update the head to the next node, free the removed node, and return the removed node's data.

DSA C

#include 
#include 

struct Node {
    int data;
    struct Node* next;
};

int pop(struct Node** head) {
    // Remove the top node and return its data
    // Your code here
}

int main() {
    struct Node* node1 = (struct Node*)malloc(sizeof(struct Node));
    struct Node* node2 = (struct Node*)malloc(sizeof(struct Node));
    struct Node* node3 = (struct Node*)malloc(sizeof(struct Node));

    node1->data = 10;
    node1->next = NULL;

    node2->data = 20;
    node2->next = node1;

    node3->data = 30;
    node3->next = node2;

    struct Node* head = node3;

    return 0;
}

Hint

Use a temporary pointer to hold the top node, update the head to the next node, free the old top node, and return its data.

3

Pop the top node from the stack

In main, call the pop function with the address of head and store the returned value in an int popped_value variable.

DSA C

#include 
#include 

struct Node {
    int data;
    struct Node* next;
};

int pop(struct Node** head) {
    if (*head == NULL) {
        return -1; // Return -1 if stack is empty
    }
    struct Node* temp = *head;
    int popped_data = temp->data;
    *head = temp->next;
    free(temp);
    return popped_data;
}

int main() {
    struct Node* node1 = (struct Node*)malloc(sizeof(struct Node));
    struct Node* node2 = (struct Node*)malloc(sizeof(struct Node));
    struct Node* node3 = (struct Node*)malloc(sizeof(struct Node));

    node1->data = 10;
    node1->next = NULL;

    node2->data = 20;
    node2->next = node1;

    node3->data = 30;
    node3->next = node2;

    struct Node* head = node3;

    // Call pop and store the popped value
    // Your code here

    return 0;
}

Hint

Call pop with &head and save the result in popped_value.

4

Print the remaining stack after pop

Write a while loop to print the data of each node in the linked list starting from head. Print each value followed by -> . After the loop, print null to show the end of the list. Also, print the popped value with the message Popped value: .

DSA C

#include 
#include 

struct Node {
    int data;
    struct Node* next;
};

int pop(struct Node** head) {
    if (*head == NULL) {
        return -1; // Return -1 if stack is empty
    }
    struct Node* temp = *head;
    int popped_data = temp->data;
    *head = temp->next;
    free(temp);
    return popped_data;
}

int main() {
    struct Node* node1 = (struct Node*)malloc(sizeof(struct Node));
    struct Node* node2 = (struct Node*)malloc(sizeof(struct Node));
    struct Node* node3 = (struct Node*)malloc(sizeof(struct Node));

    node1->data = 10;
    node1->next = NULL;

    node2->data = 20;
    node2->next = node1;

    node3->data = 30;
    node3->next = node2;

    struct Node* head = node3;

    int popped_value = pop(&head);

    // Print the popped value and remaining stack
    // Your code here

    return 0;
}

Hint

Use a while loop to print each node's data followed by -> . After the loop, print null. Also print the popped value before the list.

Practice

1. What does the pop operation do in a linked list implemented as a stack?

easy

A. Deletes the entire linked list

B. Adds a new node at the end of the linked list

C. Removes and returns the first node (top) of the linked list

D. Returns the last node without removing it

Solution

1. Step 1: Understand pop operation in stack

   Pop removes the top element from the stack, which is the first node in a linked list stack.

2. Step 2: Apply to linked list

   In a linked list used as a stack, the first node is removed and returned during pop.

3. Final Answer:

   Removes and returns the first node (top) of the linked list -> Option C

4. Quick Check:

   Pop = remove first node [OK]

Hint: Pop removes the first node in linked list stack [OK]

Common Mistakes:

• Thinking pop removes last node
• Confusing pop with push
• Assuming pop deletes entire list

2. Which of the following is the correct syntax to pop a node from a linked list stack in C?

easy

A. node* pop(node** head) { node* temp = *head; *head = (*head)->next; return temp; }

B. node pop(node head) { head = head->next; return head; }

C. void pop(node* head) { head = head->next; }

D. node* pop(node* head) { head = head->next; return head; }

Solution

1. Step 1: Check parameter passing for head pointer

   To modify the head pointer, we pass a pointer to pointer (node** head).

2. Step 2: Verify pop logic

   Store current head in temp, move head to next node, return temp node.

3. Final Answer:

   node* pop(node** head) { node* temp = *head; *head = (*head)->next; return temp; } -> Option A

4. Quick Check:

   Pointer to pointer needed to update head [OK]

Hint: Use node** to update head pointer in pop [OK]

Common Mistakes:

• Passing head by value instead of pointer to pointer
• Returning wrong node or void
• Not updating head pointer correctly

3. What will be the output of the following code snippet?

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

node* pop(node** head) {
  if (*head == NULL) return NULL;
  node* temp = *head;
  *head = (*head)->next;
  return temp;
}

int main() {
  node n3 = {3, NULL};
  node n2 = {2, &n3};
  node n1 = {1, &n2};
  node* head = &n1;
  node* popped = pop(&head);
  printf("%d -> %d -> %d -> NULL", head->data, head->next->data, head->next->next->data);
  return 0;
}

medium

A. 2 -> 3 -> 0 -> NULL

B. 2 -> 3 -> NULL -> NULL

C. 2 -> 3 -> NULL

D. 2 -> 3 -> (segmentation fault)

Solution

1. Step 1: Trace pop operation

   Pop removes node with data 1, head now points to node with data 2.

2. Step 2: Trace printf arguments

   head->data = 2, head->next->data = 3, head->next->next = NULL, accessing ->data causes segmentation fault after printing "2 -> 3 -> " .

3. Final Answer:

   2 -> 3 -> (segmentation fault) -> Option D

4. Quick Check:

   Accessing NULL->data causes crash [OK]

Hint: Accessing next of last node causes crash [OK]

Common Mistakes:

• Assuming NULL prints as 'NULL' string
• Ignoring segmentation fault on NULL dereference
• Misreading linked list after pop

4. Identify the bug in this pop function and select the correct fix:

node* pop(node* head) {
  node* temp = head;
  head = head->next;
  return temp;
}

medium

A. Pass head as node** and update *head inside function

B. Return head instead of temp

C. Set temp->next = NULL before return

D. No bug, function is correct

Solution

1. Step 1: Analyze head pointer update

   Function updates local copy of head, original head outside remains unchanged.

2. Step 2: Fix pointer update

   Pass pointer to pointer (node**) to modify original head pointer.

3. Final Answer:

   Pass head as node** and update *head inside function -> Option A

4. Quick Check:

   Use node** to update head pointer [OK]

Hint: Use node** to update head pointer in pop [OK]

Common Mistakes:

• Updating local copy of head only
• Not passing pointer to pointer
• Returning wrong node

5. Given a linked list stack with nodes containing integers, write the logic to pop all nodes and print their data in order. Which approach is correct?

hard

A. Traverse list without popping and print data

B. Use a loop: while head != NULL, pop node, print data, free node

C. Pop once, print data, then stop

D. Recursively call pop until head is NULL, then print all data after recursion

Solution

1. Step 1: Understand popping all nodes

   Pop removes top node each time, so loop until list is empty.

2. Step 2: Print and free nodes in loop

   Print data of popped node immediately, then free memory to avoid leaks.

3. Final Answer:

   Use a loop: while head != NULL, pop node, print data, free node -> Option B

4. Quick Check:

   Loop pop-print-free until empty [OK]

Hint: Loop pop until head NULL, print and free each node [OK]

Common Mistakes:

• Recursing without printing in correct order
• Not freeing nodes causing memory leaks
• Stopping after one pop