Linked List vs Array When to Choose Which in DSA C++ - Interactive Comparison Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare an array of 5 integers in C++.

DSA C++

int arr[[1]];

Drag options to blanks, or click blank then click option'

A1

B10

C5

D0

Attempts:

3 left

💡 Hint

Common Mistakes

Using zero as size which creates an empty array.

Using a size larger than needed without reason.

The array size must be specified as 5 to create an array of 5 integers.

2fill in blank

medium

Complete the code to create a singly linked list node struct in C++.

DSA C++

struct Node {
    int data;
    [1] *next;
};

Drag options to blanks, or click blank then click option'

ANode

Bint

Cstruct

Dpointer

Attempts:

3 left

💡 Hint

Common Mistakes

Using int* instead of Node* for the next pointer.

Forgetting the * to declare a pointer.

The next pointer must be of type Node* to point to the next node in the linked list.

3fill in blank

hard

Fix the error in the code to insert a new node at the beginning of a linked list.

DSA C++

void insertAtHead(Node*& head, int val) {
    Node* newNode = new Node();
    newNode->data = val;
    newNode->next = [1];
    head = newNode;
}

Drag options to blanks, or click blank then click option'

Ahead->next

Bhead

CnewNode

Dnullptr

Attempts:

3 left

💡 Hint

Common Mistakes

Setting newNode->next to nullptr which breaks the list.

Setting newNode->next to newNode causing a cycle.

The new node's next pointer should point to the current head before updating head to newNode.

4fill in blank

hard

Fill both blanks to create a function that returns the length of a linked list.

DSA C++

int length(Node* head) {
    int count = 0;
    while (head [1] nullptr) {
        count++;
        head = head[2];
    }
    return count;
}

Drag options to blanks, or click blank then click option'

A!=

B->next

C==

Dnext

Attempts:

3 left

💡 Hint

Common Mistakes

Using == instead of != in the while condition.

Using head.next instead of head->next.

The loop continues while head is not nullptr, and head moves to the next node using head->next.

5fill in blank

hard

Fill all three blanks to create a function that converts an array to a linked list.

DSA C++

Node* arrayToList(int arr[], int size) {
    Node* head = nullptr;
    for (int i = [1]; i [2] size; i++) {
        Node* newNode = new Node();
        newNode->data = arr[i];
        newNode->next = head;
        head = [3];
    }
    return head;
}

Drag options to blanks, or click blank then click option'

A0

B<

CnewNode

Dsize

Attempts:

3 left

💡 Hint

Common Mistakes

Starting loop at 1 instead of 0.

Using <= instead of < in the loop condition.

Assigning head to arr[i] instead of newNode.

The loop starts at 0, runs while i is less than size, and head is updated to newNode each iteration.

Practice

1. Which data structure is better when you need fast random access to elements by index?

easy

A. Queue

B. Array

C. Stack

D. Linked List

Solution

1. Step 1: Understand random access requirement

   Random access means accessing any element directly by its position quickly.

2. Step 2: Compare array and linked list access times

   Arrays allow direct access by index in constant time, while linked lists require traversal.

3. Final Answer:

   Array -> Option B

4. Quick Check:

   Random access = Array [OK]

Hint: For fast index access, choose arrays [OK]

Common Mistakes:

• Thinking linked lists provide fast random access
• Confusing stack or queue with random access
• Ignoring traversal cost in linked lists

2. Which of the following is the correct way to declare a dynamic array in C++?

easy

A. int arr[] = new int(10);

B. int arr[10];

C. int arr = new int[10];

D. int* arr = new int[10];

Solution

1. Step 1: Identify dynamic array syntax in C++

   Dynamic arrays use pointers with 'new' keyword and size in brackets.

2. Step 2: Check each option

   int* arr = new int[10]; correctly uses 'int* arr = new int[10];'. Others are either static arrays or incorrect syntax.

3. Final Answer:

   int* arr = new int[10]; -> Option D

4. Quick Check:

   Dynamic array = new int[size] [OK]

Hint: Use 'new' with pointer for dynamic arrays in C++ [OK]

Common Mistakes:

• Using static array syntax for dynamic arrays
• Missing pointer (*) in declaration
• Incorrect use of parentheses instead of brackets

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

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

Node* head = new Node{1, nullptr};
head->next = new Node{2, nullptr};
head->next->next = new Node{3, nullptr};

Node* temp = head;
while(temp != nullptr) {
  std::cout << temp->data << " ";
  temp = temp->next;
}

medium

A. 1 2 3

B. 3 2 1

C. 1 3 2

D. Compilation error

Solution

1. Step 1: Understand linked list creation

   Nodes are created with values 1, 2, 3 linked in order: head -> 1 -> 2 -> 3 -> nullptr.

2. Step 2: Trace the while loop output

   Loop prints data of each node from head to end: 1, then 2, then 3, each followed by space.

3. Final Answer:

   1 2 3 -> Option A

4. Quick Check:

   Traverse linked list prints 1 2 3 [OK]

Hint: Traverse linked list from head to print data [OK]

Common Mistakes:

• Confusing order of nodes
• Forgetting to update temp pointer
• Assuming array-like indexing

4. Identify the error in the following code that tries to insert a new node at the beginning of a linked list:

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

void insertAtHead(Node* head, int val) {
  Node* newNode = new Node{val, nullptr};
  newNode->next = head;
  head = newNode;
}

medium

A. head pointer is passed by value, so original list is not updated

B. Missing return type in function

C. newNode->next should be nullptr

D. Memory leak due to not deleting old head

Solution

1. Step 1: Analyze function parameter passing

   head is passed by value, so changes inside function do not affect original head pointer.

2. Step 2: Understand effect on linked list

   Assigning head = newNode only changes local copy; original list head remains unchanged.

3. Final Answer:

   head pointer is passed by value, so original list is not updated -> Option A

4. Quick Check:

   Pass pointer by reference to update list head [OK]

Hint: Pass head by reference to modify original list [OK]

Common Mistakes:

• Assuming pointer changes affect caller without reference
• Incorrect next pointer assignment
• Ignoring memory management

5. You need to store a large collection of elements where insertions and deletions happen frequently at random positions. Which data structure is more suitable and why?

hard

A. Array, because it provides fast random access

B. Array, because it uses less memory than linked list

C. Linked List, because it allows efficient insertions and deletions without shifting elements

D. Linked List, because it supports binary search efficiently

Solution

1. Step 1: Understand operation requirements

   Frequent insertions and deletions at random positions require efficient element rearrangement.

2. Step 2: Compare array and linked list for these operations

   Arrays require shifting elements on insert/delete, which is costly. Linked lists adjust pointers, making these operations efficient.

3. Final Answer:

   Linked List, because it allows efficient insertions and deletions without shifting elements -> Option C

4. Quick Check:

   Frequent insert/delete = Linked List [OK]

Hint: Use linked list for frequent insertions/deletions [OK]

Common Mistakes:

• Choosing array for frequent insert/delete ignoring shift cost
• Thinking linked list supports fast random access
• Confusing binary search applicability