Memory Layout Comparison Array vs Linked List in DSA C# - Interactive Comparison Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare an array of integers with 5 elements.

DSA C#

int[] numbers = new int[[1]];

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

A5

B(5)

C{5}

D<5>

Attempts:

3 left

💡 Hint

Common Mistakes

Using parentheses instead of square brackets.

Using curly braces which are for initialization, not size.

The correct syntax to declare an array of 5 integers in C# uses square brackets with the size inside: [5].

2fill in blank

medium

Complete the code to create a new node for a singly linked list in C#.

DSA C#

Node newNode = new Node([1]);

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

Anull

B5

C"data"

D0

Attempts:

3 left

💡 Hint

Common Mistakes

Passing null instead of data.

Passing a string when expecting an integer.

When creating a new node, you pass the data value, here the integer 5.

3fill in blank

hard

Fix the error in the linked list traversal code by completing the blank.

DSA C#

while (current != [1]) {
    Console.WriteLine(current.Data);
    current = current.Next;
}

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

Anull

B0

Chead

Dfalse

Attempts:

3 left

💡 Hint

Common Mistakes

Checking against 0 or false which are not valid for reference types.

Checking against head which is the start, not the end.

The traversal should continue until current is null, which means the end of the list.

4fill in blank

hard

Fill both blanks to create a dictionary that maps array indices to linked list nodes.

DSA C#

Dictionary<int, Node> map = new Dictionary<int, Node>();
for (int i = 0; i [1] array.Length; i++) {
    map.Add(i, [2]);
}

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

A<

BlinkedList.Head

Carray[i]

DlinkedList.GetNodeAt(i)

Attempts:

3 left

💡 Hint

Common Mistakes

Using > or >= in the loop condition causing no iterations.

Adding array elements instead of linked list nodes.

The loop runs while i < array.Length. The map adds the index i and the node at that index from the linked list using GetNodeAt(i).

5fill in blank

hard

Fill all three blanks to create a method that compares memory layout sizes of an array and a linked list.

DSA C#

public void CompareMemory(int[] arr, Node head) {
    int arraySize = sizeof(int) * [1];
    int nodeSize = (sizeof(int) + sizeof(IntPtr)) * [2];
    Console.WriteLine("Array size: " + arraySize + ", Linked list size: " + [3]);
}

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

Aarr.Length

BCountNodes(head)

CnodeSize

Darr.Length + 1

Attempts:

3 left

💡 Hint

Common Mistakes

Using incorrect length or count values.

Printing wrong variables in the output.

The array size is the size of int times the array length. The linked list size is the size of Node times the number of nodes counted by CountNodes(head). The output prints both sizes.

Practice

1. Which of the following best describes the memory layout of an array in C#?

easy

A. Elements are stored in contiguous memory locations.

B. Elements are scattered randomly in memory with pointers linking them.

C. Elements are stored in a tree-like structure in memory.

D. Elements are stored in separate memory blocks with no order.

Solution

1. Step 1: Understand array memory layout

   Arrays store elements one after another in a continuous block of memory.

2. Step 2: Compare with other structures

   Unlike linked lists, arrays do not use pointers between elements; they rely on index positions.

3. Final Answer:

   Elements are stored in contiguous memory locations. -> Option A

4. Quick Check:

   Array = contiguous memory [OK]

Hint: Arrays use continuous memory blocks, unlike linked lists [OK]

Common Mistakes:

• Thinking arrays use pointers between elements
• Confusing linked list layout with array layout
• Assuming arrays store elements randomly

2. Which C# syntax correctly declares a linked list of integers using the built-in LinkedList<int> class?

easy

A. LinkedList<int> list = LinkedList<int>();

B. LinkedList list = new LinkedList<int>();

C. LinkedList<int> list = new LinkedList<int>();

D. LinkedList<int> list = new LinkedList();

Solution

1. Step 1: Check correct generic syntax

   In C#, generic collections require specifying the type in angle brackets on both sides when creating an instance.

2. Step 2: Validate each option

   LinkedList<int> list = new LinkedList<int>(); correctly uses new LinkedList<int>(). Others miss type or use wrong syntax.

3. Final Answer:

   LinkedList<int> list = new LinkedList<int>(); -> Option C

4. Quick Check:

   Generic type must be specified on both sides [OK]

Hint: Use new LinkedList<int>() to create linked list [OK]

Common Mistakes:

• Omitting generic type on constructor
• Using non-generic LinkedList without type
• Missing 'new' keyword

3. Consider the following C# code snippet:

int[] arr = new int[3] {10, 20, 30};
LinkedList<int> list = new LinkedList<int>();
list.AddLast(10);
list.AddLast(20);
list.AddLast(30);

Console.WriteLine(arr[1]);
Console.WriteLine(list.First.Next.Value);

What will be the output?

medium

A. 10\n20

B. 20\n20

C. 20\n10

D. 30\n20

Solution

1. Step 1: Analyze array access

   arr[1] accesses the second element in the array, which is 20.

2. Step 2: Analyze linked list traversal

   list.First is 10, list.First.Next is 20, so list.First.Next.Value is 20.

3. Final Answer:

   20\n20 -> Option B

4. Quick Check:

   Array index 1 and linked list second node both 20 [OK]

Hint: Array index and linked list next node give same value [OK]

Common Mistakes:

• Confusing linked list first and next nodes
• Using wrong array index
• Assuming linked list nodes are zero-indexed

4. The following code attempts to traverse a linked list and print all values:

LinkedList<int> list = new LinkedList<int>();
list.AddLast(1);
list.AddLast(2);
list.AddLast(3);

var node = list.First;
while (node != null)
{
    Console.WriteLine(node.Value);
    node = node.Next.Next;
}

What is the problem with this code?

medium

A. It skips every other node and may cause a NullReferenceException.

B. It will print all nodes correctly without issues.

C. It causes an infinite loop because node never becomes null.

D. It prints nodes in reverse order.

Solution

1. Step 1: Understand node traversal logic

   The code moves node by two steps each iteration using node = node.Next.Next;.

2. Step 2: Identify potential error

   If node.Next is null, accessing node.Next.Next causes NullReferenceException. Also, it skips nodes.

3. Final Answer:

   It skips every other node and may cause a NullReferenceException. -> Option A

4. Quick Check:

   Skipping nodes and null access cause error [OK]

Hint: Advance node by one, not two, to avoid errors [OK]

Common Mistakes:

• Assuming node.Next.Next is always valid
• Not checking for null before accessing Next
• Thinking it prints all nodes

5. You need to store a large collection of integers where insertions and deletions happen frequently at random positions. Considering memory layout and performance, which data structure is more suitable and why?

hard

A. Array, because contiguous memory improves insertion speed.

B. Array, because it uses pointers to link elements for fast insertion.

C. Linked list, because it stores elements contiguously for better cache performance.

D. Linked list, because nodes can be inserted or removed without shifting elements.

Solution

1. Step 1: Analyze insertion and deletion costs

   Arrays require shifting elements for insertions/deletions at random positions, which is costly.

2. Step 2: Understand linked list advantages

   Linked lists store elements in nodes linked by pointers, allowing insertions/deletions by changing pointers without shifting.

3. Final Answer:

   Linked list, because nodes can be inserted or removed without shifting elements. -> Option D

4. Quick Check:

   Linked list = efficient random insert/delete [OK]

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

Common Mistakes:

• Assuming arrays insert/delete faster due to contiguous memory
• Confusing pointer use in arrays
• Ignoring shifting cost in arrays