Creating a Singly Linked List from Scratch in DSA C - Debugging & Practice

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this linked list traversal?

Consider a singly linked list created with nodes containing values 10, 20, and 30 in that order. What will be printed after traversing the list?

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 = malloc(sizeof(Node));
    head->next->next->data = 30;
    head->next->next->next = NULL;

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

A 10 -> 20 -> 30 -> null

B 10 -> 20 -> null

C 30 -> 20 -> 10 -> null

D null

💡 Hint

Think about how nodes are linked and the order of traversal from head to tail.

The list is created with nodes 10, 20, and 30 linked in that order. Traversing from head prints each node's data followed by an arrow, ending with null.

🧠 Conceptual

intermediate

What happens if you forget to set the last node's next pointer to NULL?

In a singly linked list, if the last node's next pointer is not set to NULL, what is the most likely outcome when traversing the list?

A The list will automatically fix the pointer to NULL.

B The traversal will stop correctly at the last node.

C The traversal may continue into random memory causing undefined behavior or crash.

D The list will reverse itself during traversal.

💡 Hint

Think about what NULL means in a linked list.

The NULL pointer marks the end of the list. Without it, traversal continues into invalid memory, causing errors.

🔧 Debug

advanced

Why does this linked list insertion code cause a segmentation fault?

Examine the code below that tries to insert a new node at the beginning of a singly linked list. Identify the cause of the segmentation fault.

DSA C

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

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

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

A The malloc call is missing, so newNode is NULL causing a fault.

B The printf statement is incorrect and causes the fault.

C The newNode->next is not set, causing an infinite loop.

D The head pointer is passed by value, so changes inside insertAtHead do not affect the original head.

💡 Hint

Consider how pointers are passed to functions in C.

The function receives a copy of head pointer. Modifying it does not change the original head in main, so head remains NULL causing a fault when dereferenced.

📝 Syntax

advanced

Which option correctly defines a node struct for a singly linked list in C?

Choose the correct C struct definition for a singly linked list node holding an integer data.

A

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

B

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

C

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

D

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

💡 Hint

Remember how to refer to the struct type inside itself.

Option B correctly uses 'struct Node* next;' inside the struct and typedefs it as Node.

🚀 Application

expert

What is the output after inserting nodes 1, 2, 3 at the head in order?

Starting with an empty singly linked list, you insert nodes with values 1, then 2, then 3 at the head. What is the final printed list?

DSA C

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

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

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

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

int main() {
    Node* head = NULL;
    insertAtHead(&head, 1);
    insertAtHead(&head, 2);
    insertAtHead(&head, 3);
    printList(head);
    return 0;
}

A 3 -> 2 -> 1 -> null

B 1 -> 2 -> 3 -> null

C null

D 1 -> null

💡 Hint

Inserting at head means new nodes become the first node.

Each new node is added at the front, so the last inserted node (3) is at the head, followed by 2, then 1.

Practice

1. What is the main purpose of a singly linked list in data structures?

easy

A. To store elements with direct access by index like an array

B. To store elements in a sequence where each element points to the next

C. To store elements in a sorted order automatically

D. To store elements with multiple pointers to previous nodes

Solution

1. Step 1: Understand singly linked list structure

   A singly linked list stores elements where each node points only to the next node, forming a chain.

2. Step 2: Compare with other data structures

   Unlike arrays, singly linked lists do not provide direct index access, and unlike doubly linked lists, nodes have only one pointer.

3. Final Answer:

   To store elements in a sequence where each element points to the next -> Option B

4. Quick Check:

   Singly linked list = sequence with next pointers [OK]

Hint: Remember: singly linked list nodes have one next pointer only [OK]

Common Mistakes:

• Thinking singly linked list allows direct index access
• Confusing singly linked list with doubly linked list
• Assuming automatic sorting in singly linked list

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

easy

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

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

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

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

Solution

1. Step 1: Check pointer usage in struct

   The next pointer must be a pointer to struct Node, so use struct Node* next;.

2. Step 2: Verify typedef correctness

   typedef struct Node { int data; struct Node* next; } Node; correctly uses typedef and pointer syntax for next node.

3. Final Answer:

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

4. Quick Check:

   Node struct uses pointer to struct Node for next [OK]

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

Common Mistakes:

• Omitting 'struct' keyword before Node* inside struct
• Using 'Node* next;' without typedef defined yet
• Using 'struct Node next;' instead of pointer
• Using 'prev' pointer instead of 'next' for singly linked list

3. What will be the output of the following C code snippet that creates a singly linked list with two nodes and prints their data?

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

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

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

medium

A. 10 20

B. 20 10

C. 10

D. Compilation error

Solution

1. Step 1: Trace node creation and data assignment

   First node data is 10, second node data is 20, linked correctly.

2. Step 2: Trace printing loop

   Loop prints data of head (10), then moves to next node (20), then stops at NULL.

3. Final Answer:

   10 20 -> Option A

4. Quick Check:

   Prints nodes in order: 10 then 20 [OK]

Hint: Follow next pointers to print nodes in order [OK]

Common Mistakes:

• Confusing order of nodes printed
• Forgetting to set next of last node to NULL
• Assuming compilation error due to missing includes (not shown)

4. Identify the error in the following code that attempts to create a singly linked list node and assign data:

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

int main() {
    Node* head;
    head->data = 5;
    head->next = NULL;
    return 0;
}

medium

A. data should be a pointer, not int

B. next pointer should point to previous node

C. head is not initialized before accessing its members

D. struct Node definition is incorrect

Solution

1. Step 1: Check pointer initialization

   head is declared but not assigned memory before accessing its members.

2. Step 2: Understand consequences

   Accessing head->data without allocation causes undefined behavior or crash.

3. Final Answer:

   head is not initialized before accessing its members -> Option C

4. Quick Check:

   Pointer must be allocated before use [OK]

Hint: Always allocate memory before using pointer members [OK]

Common Mistakes:

• Assuming pointer is auto-initialized
• Confusing next pointer direction
• Thinking data must be pointer type

5. You want to create a singly linked list from scratch that stores integers 1, 2, 3 in order. Which sequence of operations correctly builds the list?

hard

A. Allocate node1, set data=1, set node1->next=NULL, allocate node2, set data=2, set node2->next=NULL, allocate node3, set data=3, set node3->next=NULL

B. Allocate node1, set data=1, allocate node2, set data=2, allocate node3, set data=3, link node3->next=node2, link node2->next=node1, set node1->next=NULL

C. Allocate node1, set data=1, link node1->next=node2, allocate node2, set data=2, link node2->next=node3, allocate node3, set data=3, set node3->next=NULL

D. Allocate node1, set data=1, allocate node2, set data=2, link node1->next=node2, allocate node3, set data=3, link node2->next=node3, set node3->next=NULL

Solution

1. Step 1: Allocate nodes and assign data in order

   Nodes must be allocated and data assigned before linking.

2. Step 2: Link nodes in correct sequence

   Link node1 to node2, node2 to node3, and node3 to NULL to end list.

3. Final Answer:

   Allocate node1, set data=1, allocate node2, set data=2, link node1->next=node2, allocate node3, set data=3, link node2->next=node3, set node3->next=NULL -> Option D

4. Quick Check:

   Correct order and linking builds list 1->2->3->NULL [OK]

Hint: Link nodes only after allocating and setting data [OK]

Common Mistakes:

• Linking nodes before allocation
• Not setting last node's next to NULL
• Linking nodes in reverse order