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.

Practice

1. What does a typical node structure in a singly linked list contain?

easy

A. Two data fields and no pointers

B. Only a data field

C. A pointer to the previous node only

D. A data field and a pointer to the next node

Solution

1. Step 1: Understand node components

   A singly linked list node stores data and a pointer to the next node to link nodes sequentially.

2. Step 2: Identify correct structure

   Only A data field and a pointer to the next node mentions both data and a pointer to the next node, which is essential for singly linked lists.

3. Final Answer:

   A data field and a pointer to the next node -> Option D

4. Quick Check:

   Node = data + next pointer [OK]

Hint: Remember: singly linked list nodes have data + next pointer [OK]

Common Mistakes:

• Thinking nodes have only data without pointers
• Confusing singly linked list with doubly linked list structure
• Assuming nodes have pointers to previous nodes in singly linked lists

2. Which of the following is the correct syntax to define a node structure in C for a singly linked list?

easy

A. struct Node { int data; int next; };

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

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

D. struct Node { int data; struct Node next; };

Solution

1. Step 1: Check pointer declaration syntax

   In C, a pointer to the same struct type must be declared as 'struct Node *next;'.

2. Step 2: Validate each option

   struct Node { int data; struct Node *next; }; correctly uses 'struct Node *next;'. struct Node { int data; int next; }; wrongly uses 'int next;'. struct Node { int data; Node *next; }; misses 'struct' keyword. struct Node { int data; struct Node next; }; uses 'struct Node next;' which causes infinite size.

3. Final Answer:

   struct Node { int data; struct Node *next; }; -> Option C

4. Quick Check:

   Pointer syntax = struct Node *next [OK]

Hint: Use 'struct Node *next;' to declare pointer inside struct [OK]

Common Mistakes:

• Omitting 'struct' keyword before Node in pointer
• Declaring next as int instead of pointer
• Declaring next as struct Node (not pointer) causing infinite size

3. Consider the following code snippet for a singly linked list node creation and linking:

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

struct Node n1, n2;
n1.data = 10;
n2.data = 20;
n1.next = &n2;
n2.next = NULL;

printf("%d -> %d -> NULL", n1.data, n1.next->data);

What is the output of this code?

medium

A. 10 -> 20 -> NULL

B. 10 -> 0 -> NULL

C. 20 -> 10 -> NULL

D. Compilation error

Solution

1. Step 1: Understand node data and linking

   n1.data is 10, n2.data is 20. n1.next points to n2, n2.next is NULL.

2. Step 2: Trace printf statement

   Printing n1.data prints 10, n1.next->data accesses n2.data which is 20.

3. Final Answer:

   10 -> 20 -> NULL -> Option A

4. Quick Check:

   n1.data=10, n1.next->data=20 [OK]

Hint: Follow pointers step-by-step to find data values [OK]

Common Mistakes:

• Confusing pointer dereference syntax
• Assuming n1.next->data is zero or garbage
• Mixing up node data values

4. Identify the error in the following node structure definition and fix it:

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

medium

A. Change 'struct Node next;' to 'struct Node *next;'

B. Change 'int data;' to 'int *data;'

C. Remove 'struct' keyword before Node

D. Add a semicolon after struct definition

Solution

1. Step 1: Analyze the error in struct member

   Declaring 'struct Node next;' inside struct causes infinite size because it embeds the whole struct inside itself.

2. Step 2: Correct pointer usage

   To link nodes, use a pointer 'struct Node *next;' to refer to another node without embedding it.

3. Final Answer:

   Change 'struct Node next;' to 'struct Node *next;' -> Option A

4. Quick Check:

   Use pointer for next node to avoid infinite size [OK]

Hint: Use pointer for next node, not struct itself [OK]

Common Mistakes:

• Using struct Node instead of pointer causes infinite size
• Changing data type unnecessarily
• Ignoring pointer syntax rules

5. You want to design a node structure for a doubly linked list in C. Which of the following is the correct structure to hold an integer data and pointers to both previous and next nodes?

hard

A. struct Node { int data; int *prev; int *next; };

B. struct Node { int data; struct Node *prev; struct Node *next; };

C. struct Node { int data; struct Node prev; struct Node next; };

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

Solution

1. Step 1: Understand doubly linked list node requirements

   A doubly linked list node must have data and two pointers: one to previous node and one to next node.

2. Step 2: Check pointer types and struct usage

   struct Node { int data; struct Node *prev; struct Node *next; }; correctly declares pointers to struct Node for prev and next. struct Node { int data; struct Node prev; struct Node next; }; wrongly embeds structs causing infinite size. struct Node { int data; int *prev; int *next; }; uses int pointers incorrectly. struct Node { int data; struct Node *next; }; misses prev pointer.

3. Final Answer:

   struct Node { int data; struct Node *prev; struct Node *next; }; -> Option B

4. Quick Check:

   Doubly linked list node = data + prev pointer + next pointer [OK]

Hint: Doubly linked list nodes have prev and next pointers [OK]

Common Mistakes:

• Embedding struct instead of using pointers
• Using wrong pointer types for prev and next
• Omitting prev pointer in doubly linked list node