LinkedList usage in C Sharp (C#) - Step-by-Step Execution

Concept Flow - LinkedList usage

Create LinkedList object

↓

Add nodes (AddFirst/AddLast)

↓

Traverse nodes from Head

↓

Access or modify node values

↓

Remove nodes (Remove/RemoveFirst/RemoveLast)

↓

Check if list is empty or contains value

↓

End of operations

This flow shows how to create a linked list, add nodes, traverse them, modify or remove nodes, and check list properties.

Execution Sample

C Sharp (C#)

var list = new LinkedList<int>();
list.AddLast(10);
list.AddFirst(5);
list.AddLast(15);
foreach(var val in list) Console.Write(val + " ");

Creates a linked list, adds three numbers, then prints them in order.

Execution Table

Step	Operation	LinkedList Nodes	Pointer Changes	Visual State
1	Create LinkedList<int> list	empty	head=null, tail=null	[]
2	AddLast(10)	10	head=Node(10), tail=Node(10)	[10]
3	AddFirst(5)	5 -> 10	head=Node(5), tail=Node(10)	[5 -> 10]
4	AddLast(15)	5 -> 10 -> 15	tail=Node(15)	[5 -> 10 -> 15]
5	Traverse and print	5 -> 10 -> 15	head=Node(5)	Output: '5 10 15 '
6	End	5 -> 10 -> 15	no change	Traversal complete

💡 Traversal ends after last node (Node with 15) is processed.

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	After Step 5	Final
list.Count	0	1	2	3	3	3
list.Head.Value	null	10	5	5	5	5
list.Tail.Value	null	10	10	15	15	15

Key Moments - 3 Insights

Why does AddFirst(5) put 5 before 10 in the list?

AddFirst inserts a new node at the start, so the new node becomes the head, pushing existing nodes after it. See execution_table step 3 where head changes to Node(5).

How does the list keep track of the last node after AddLast(15)?

AddLast updates the tail pointer to the new node. The previous tail's next pointer links to the new node. See execution_table step 4 where tail changes to Node(15).

What happens during traversal in the foreach loop?

Traversal starts at head and moves through each node's next pointer until the end (null). Output is generated in order. See execution_table step 5.

Visual Quiz - 3 Questions

Look at the execution_table at step 3, what is the head node's value?

A 15

B 5

C 10

D null

💡 Hint

Check the 'Pointer Changes' and 'LinkedList Nodes' columns at step 3.

At which step does the list contain three nodes?

A Step 2

B Step 3

C Step 4

D Step 5

💡 Hint

Look at the 'LinkedList Nodes' column and 'list.Count' in variable_tracker.

If we remove the first node after step 4, what would be the new head value?

A 10

B 5

C 15

D null

💡 Hint

Removing the first node moves head to the next node. See how AddFirst and AddLast set head and tail.

Concept Snapshot

LinkedList usage in C#:
- Create with LinkedList<T> list = new LinkedList<T>();
- Add nodes: AddFirst(value), AddLast(value)
- Traverse with foreach(var item in list)
- Remove nodes: Remove(value), RemoveFirst(), RemoveLast()
- Head and Tail track start/end nodes
- Count gives number of nodes

Full Transcript

This example shows how to use a LinkedList in C#. First, we create an empty list. Then we add nodes using AddLast and AddFirst, which update the head and tail pointers accordingly. The list nodes link in order, allowing traversal from head to tail. The foreach loop visits each node in order, printing their values. Key points include how AddFirst inserts at the start, changing the head, and AddLast appends at the end, changing the tail. The variable tracker shows how count and pointers change after each operation. This helps understand the linked list structure and usage.

Practice

1. What is a key characteristic of a LinkedList in C#?

easy

A. It stores elements in nodes linked by references.

B. It stores elements in a fixed-size array.

C. It only allows adding elements at the end.

D. It cannot remove elements once added.

Solution

1. Step 1: Understand LinkedList structure

   A LinkedList stores elements in nodes, where each node points to the next (and possibly previous) node.

2. Step 2: Compare options with LinkedList behavior

   Only It stores elements in nodes linked by references. correctly describes this linked node structure; others describe arrays or incorrect behaviors.

3. Final Answer:

   It stores elements in nodes linked by references. -> Option A

4. Quick Check:

   LinkedList = nodes linked by references [OK]

Hint: LinkedList uses nodes connected by links, not arrays. [OK]

Common Mistakes:

• Thinking LinkedList uses arrays internally
• Assuming LinkedList only adds at the end
• Believing LinkedList cannot remove elements

2. Which of the following is the correct way to add an element at the start of a LinkedList<int> named list?

easy

A. list.AddStart(10);

B. list.AddFirst(10);

C. list.InsertAt(0, 10);

D. list.PushFront(10);

Solution

1. Step 1: Recall LinkedList method names

   The method to add an element at the start is AddFirst.

2. Step 2: Check each option's validity

   Only AddFirst is a valid LinkedList method; others are invalid or do not exist.

3. Final Answer:

   list.AddFirst(10); -> Option B

4. Quick Check:

   AddFirst adds at start [OK]

Hint: Use AddFirst to add at the start of LinkedList. [OK]

Common Mistakes:

• Using non-existent methods like AddStart or PushFront
• Confusing LinkedList with List methods
• Trying to use InsertAt which LinkedList does not have

3. What will be the output of this C# code?

var list = new LinkedList<string>();
list.AddLast("apple");
list.AddFirst("banana");
list.AddLast("cherry");
foreach(var item in list) Console.Write(item + " ");

medium

A. banana apple cherry

B. apple banana cherry

C. cherry apple banana

D. banana cherry apple

Solution

1. Step 1: Track insertion order

   First, "apple" is added last, so list: apple. Then "banana" added first, so list: banana, apple. Then "cherry" added last, so list: banana, apple, cherry.

2. Step 2: Understand foreach iteration order

   Foreach iterates from first to last node, so output is "banana apple cherry ".

3. Final Answer:

   banana apple cherry -> Option A

4. Quick Check:

   First = banana, last = cherry [OK]

Hint: AddFirst puts item at start; AddLast at end. [OK]

Common Mistakes:

• Assuming AddLast adds at start
• Confusing order of AddFirst and AddLast
• Expecting output in reverse order

4. Identify the error in this code snippet:

var list = new LinkedList<int>();
list.AddFirst(1);
list.AddLast(2);
list.Remove(3);
Console.WriteLine(list.Count);

medium

A. Remove(3) throws an exception because 3 is not in the list.

B. Count property does not exist on LinkedList.

C. AddFirst and AddLast methods are invalid for LinkedList.

D. Remove(3) does nothing since 3 is not found; Count remains 2.

Solution

1. Step 1: Understand Remove behavior

   Remove(value) tries to remove the first node with that value. If not found, it does nothing and returns false; no exception is thrown.

2. Step 2: Check Count after removal attempt

   Since 3 is not in the list, list remains with 2 elements; Count is 2.

3. Final Answer:

   Remove(3) does nothing since 3 is not found; Count remains 2. -> Option D

4. Quick Check:

   Remove missing value = no error, Count unchanged [OK]

Hint: Remove missing item does not throw error, just returns false. [OK]

Common Mistakes:

• Expecting Remove to throw exception if item missing
• Thinking AddFirst/AddLast are invalid
• Assuming Count is not a property

5. Given a LinkedList<int> with values 1, 2, 3, 4, 5, which code snippet correctly removes all even numbers from the list?

hard

A. foreach(var node in list) { if(node % 2 == 0) list.Remove(node); }

B. for(int i = 0; i < list.Count; i++) { if(list.ElementAt(i) % 2 == 0) list.Remove(list.ElementAt(i)); }

C. var current = list.First; while(current != null) { var next = current.Next; if(current.Value % 2 == 0) list.Remove(current); current = next; }

D. list.RemoveAll(x => x % 2 == 0);

Solution

1. Step 1: Understand safe removal during iteration

   Removing nodes while iterating requires storing next node before removal to avoid invalid references.

2. Step 2: Analyze each option

   foreach(var node in list) { if(node % 2 == 0) list.Remove(node); } uses foreach which throws error on modification during iteration. var current = list.First; while(current != null) { var next = current.Next; if(current.Value % 2 == 0) list.Remove(current); current = next; } correctly uses a while loop with next node saved. for(int i = 0; i < list.Count; i++) { if(list.ElementAt(i) % 2 == 0) list.Remove(list.ElementAt(i)); } uses ElementAt which is inefficient and unsafe. list.RemoveAll(x => x % 2 == 0); is invalid as LinkedList has no RemoveAll method.

3. Final Answer:

   var current = list.First; while(current != null) { var next = current.Next; if(current.Value % 2 == 0) list.Remove(current); current = next; } -> Option C

4. Quick Check:

   Use while loop with next saved to remove nodes safely [OK]

Hint: Save next node before removal to avoid iteration errors. [OK]

Common Mistakes:

• Modifying list inside foreach causes runtime error
• Using RemoveAll which LinkedList does not have
• Using ElementAt which is inefficient and unsafe