Node Structure and Pointer Design in DSA C - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Linked List Node Traversal

What is the printed output of the linked list traversal code below?

DSA C

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

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

int main() {
    Node* head = malloc(sizeof(Node));
    head->data = 10;
    head->next = malloc(sizeof(Node));
    head->next->data = 20;
    head->next->next = NULL;

    Node* current = head;
    while (current != NULL) {
        printf("%d -> ", current->data);
        current = current->next;
    }
    printf("NULL\n");
    return 0;
}

A NULL

B 10 -> NULL

C 20 -> 10 -> NULL

D 10 -> 20 -> NULL

💡 Hint

Trace the linked list starting from head and follow the next pointers until NULL.

The code creates two nodes linked together: first node with data 10 points to second node with data 20, which points to NULL. Traversal prints 10 then 20 then NULL.

🧠 Conceptual

intermediate

Pointer Usage in Doubly Linked List Node

In a doubly linked list node structure, which pointer is used to access the previous node?

A next pointer

B prev pointer

C head pointer

D tail pointer

💡 Hint

Think about which pointer points backward in the list.

The 'prev' pointer in a doubly linked list node points to the previous node, allowing backward traversal.

❓ Predict Output

advanced

Output of Circular Linked List Traversal

What is the output of the following circular linked list traversal code?

DSA C

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

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

int main() {
    Node* head = malloc(sizeof(Node));
    head->data = 1;
    Node* second = malloc(sizeof(Node));
    second->data = 2;
    Node* third = malloc(sizeof(Node));
    third->data = 3;

    head->next = second;
    second->next = third;
    third->next = head; // circular link

    Node* current = head;
    int count = 0;
    while (count < 5) {
        printf("%d -> ", current->data);
        current = current->next;
        count++;
    }
    printf("...\n");
    return 0;
}

A 1 -> 2 -> 3 -> 1 -> 2 -> ...

B 1 -> 2 -> 3 -> 4 -> 5 -> ...

C 1 -> 2 -> 3 -> NULL

D 1 -> 2 -> NULL

💡 Hint

The last node points back to the head, so traversal loops.

The circular linked list loops through nodes 1, 2, 3 repeatedly. The code prints 5 nodes, so output is 1 2 3 1 2 ...

🔧 Debug

advanced

Identify the Pointer Bug in Node Insertion

What error will occur when running this code to insert a new node at the beginning of a singly linked list?

DSA C

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

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

void insertAtHead(Node** head, int val) {
    Node* newNode = malloc(sizeof(Node));
    newNode->data = val;
    newNode->next = *head;
    *head = newNode;
}

int main() {
    Node* head = NULL;
    insertAtHead(&head, 5);
    printf("%d -> NULL\n", head->data);
    return 0;
}

A Prints '5 -> NULL' correctly

B Segmentation fault (crash) due to invalid pointer update

C Compilation error due to missing semicolon

D Prints garbage value

💡 Hint

Check how the head pointer is passed and updated.

The function insertAtHead now receives a pointer to head, so updating *head inside affects main's head pointer. The code prints correctly.

🧠 Conceptual

expert

Memory Layout of a Node with Multiple Pointers

Consider a node structure with three pointers: next, prev, and random (pointing to any node). What is the minimum number of pointers needed to traverse the list in both directions and also jump randomly?

A 1 pointer: next only

B 2 pointers: next and prev only

C 3 pointers: next, prev, random

D 4 pointers: next, prev, random, and head

💡 Hint

Think about what each pointer is used for in traversal and random access.

To traverse forward and backward, next and prev are needed. To jump randomly, a random pointer is required. So minimum is 3 pointers.