COURSE: DATA STRUCTURES & ALGORITHMS
SECTION 02 // LINKED LISTS
C++ DATA STRUCTURES•SPRING
Section 2 — Data Structures
Linked Lists & Pointer Operations
Understand how nodes connect, how pointers move, and how linked lists change through operations.
WHAT WE'LL COVER17 SLIDES
- 01Cover
- 02Array vs. Linked List
- 03Anatomy of a Node
- 04Building the List
- 05Insert at Beginning
- 06Insert at End
- 07Insert at a Position
- 08Delete from Beginning
- 09Delete at End
- 10Delete at a Position
- 11Traversal
- 12Searching
- 13Edge Cases
- 14C++ Implementation
- 15Complete Walkthrough
- 16Predict the Output
- 17Key Takeaways
C++ · Singly Linked List
SECTION 02: MOTIVATION
SLIDE 02 // ARRAY VS. LINKED LIST
MEMORY LAYOUT & ACCESS
Section 2 — Motivation
Array vs. Linked List
ARRAYOne contiguous block — elements sit side by side.
LINKED LISTSeparate nodes — each node links to the next.
An array is navigated by index; a linked list is navigated by following pointers.
ASPECTARRAYLINKED LIST
MemoryOne contiguous blockNodes at scattered addresses
AccessBy index:
arr[i]By following nextInsert / DeleteShifts the remaining cellsNo shifting — yet the position may need traversal
SizeFixed size in a standard C++ arrayGrows one node at a time
Array — contiguous cells, reached by index
[0]100x1000
[1]200x1004
[2]300x1008
[3]—0x100C
Insert 15 at index 1 — press “Animate Insertion”.
INDEX IS THE LINKPosition is implied by the address — the cells must stay adjacent.
Linked List — nodes at scattered addresses, joined by next
@ 0x4A20
data10next•
@ 0x1F80
data20next•
@ 0x8C10
nullptrdata30next•
NOT ADJACENTNodes may live anywhere in memory — the pointer is the only link forward.
SECTION 02: FOUNDATIONS
SLIDE 03 // ANATOMY OF A NODE
data•next•head•tail•nullptr
The Building Block
Anatomy of a Node
NAMEROLETYPE
dataThe value stored inside the node.
intnextAddress of the following node.
Node*headReference to the first node.
Node*tailReference to the last node.
Node*nullptrEnd marker — the last node has no successor.
Node*ONE NODE — TWO FIELDSPAYLOAD + POINTER
data — int20next — Node*•
REFERENCES INTO THE CHAINhead / tail / nullptr
head
data10next•
data20next•
tail
nullptrdata30next•
NODE.CPPC++ STRUCT
struct Node { int data; // the value carried by the node Node* next; // pointer to the next node, or nullptr // Constructor: initialise both fields at creation Node(int value) : data(value), next(nullptr) {}};
SECTION 02: FOUNDATIONS
SLIDE 04 // BUILDING THE LIST
EMPTY → ONE → MANY
List States
Building the List
Two pointers define the whole list. Every insertion and deletion ahead is just restoring these three rules.
RULEALWAYS TRUE
HEADPoints at the first node —
nullptr only when emptyTAILPoints at the last node —
nullptr only when emptyTAIL → NEXTThe last node's
next is always nullptrSTATE 0 — EMPTY LISTSIZE 0
headnullptrtailnullptr
STATE 1 — SINGLE NODEHEAD == TAIL
head + tail
nullptrdata10next•
STATE 2 — THREE NODESTAIL IDENTIFIES THE FINAL NODE
head
data10next•
data20next•
tail
nullptrdata30next•
SECTION 02: INSERTION
SLIDE 05 // INSERT AT BEGINNING
insertAtBeginning(5)
Insert at the Front
Insert at Beginning
START10 → 20 → 30 → nullptr
AFTER insertAtBeginning(5)5 → 10 → 20 → 30 → nullptr
STEP 1
Create the node: allocate a node holding the new value; its next starts as nullptr.
new Node(5)
STEP 2
Link forward first: point the new node at the current first node (10).
newNode->next = head
STEP 3
Move the entry point: head now marks node 5 as the new front.
head = newNode
EMPTY LIST
Special case: inserting into an empty list must also set tail.
if (tail == nullptr) tail = newNode
BEFORE — head IS 10head / tail SET
head
data10next•
data20next•
tail
nullptrdata30next•
STEP 2 — newNode->next = headHEAD STILL POINTS AT 10
newNode
data5next•
head
data10next•
data20next•
tail
nullptrdata30next•
AFTER — head MOVES TO 55 → 10 → 20 → 30
head
data5next•
data10next•
data20next•
tail
nullptrdata30next•
INSERT_AT_BEGINNING.CPPC++ METHOD
void insertAtBeginning(int value) { Node* newNode = new Node(value); newNode->next = head; // link the new node forward head = newNode; // move head to the new front if (tail == nullptr) tail = newNode;}
SECTION 02: INSERTION
SLIDE 06 // INSERT AT END
insertAtEnd(40)
Insert at the Back
Insert at End
START10 → 20 → 30 → nullptr
AFTER insertAtEnd(40)10 → 20 → 30 → 40 → nullptr
EMPTY CASE
If the list is empty: the new node becomes both the first and the last node.
head = tail = newNode
STEP 1
Link the last node forward: the current tail (30) now points at the new node.
tail->next = newNode
STEP 2
Advance tail: tail now identifies the new final node (40).
tail = newNode
BEFORE — tail IS 30NO WALK NEEDED — tail IS AT HAND
head
data10next•
data20next•
tail
nullptrdata30next•
STEP 1 — tail->next = newNodeTAIL NOT YET MOVED
head
data10next•
data20next•
old tail
data30next•
newNode
nullptrdata40next•
STEP 2 — tail ADVANCES TO 4010 → 20 → 30 → 40
head
data10next•
data20next•
data30next•
tail
nullptrdata40next•
INSERT_AT_END.CPPC++ METHOD
void insertAtEnd(int value) { Node* newNode = new Node(value); if (head == nullptr) { // empty list head = tail = newNode; } else { tail->next = newNode; // link the last node forward tail = newNode; // advance tail }}
SECTION 02: INSERTION
SLIDE 07 // INSERT AT A POSITION
insertAtPosition(15, 3)
Insert in the Middle
Insert at a Position
START5 → 10 → 20 → 30 → nullptr
AFTER insertAtPosition(15, 3)5 → 10 → 15 → 20 → 30 → nullptr
STEP 1
Find the predecessor: walk pos - 1 steps from head; temp stops at node 10.
temp = node at pos - 1
STEP 2
Link forward first: connect node 15 to node 20 before touching node 10.
newNode->next = temp->next
STEP 3
Then re-link the predecessor: node 10 now points at node 15.
temp->next = newNode
POSITION 1
Front insertion repeats the begin case; an out-of-range position stops at nullptr.
if (position == 1)
STEP 1 — TEMP STOPS AT 10POSITION 3 → PREDECESSOR IS 10
head
data5next•
temp
data10next•
data20next•
tail
nullptrdata30next•
STEP 2 — newNode->next = temp->next15 POINTS AT 20 · NODE 10 UNCHANGED
head
data5next•
temp
data10next•
data20next•
tail
nullptrdata30next•
new nodeOnly
newNode
data15next•
data20next•
newNode->next changed — node 10 still points at 20.STEP 3 — temp->next = newNodeRESULT: 5 → 10 → 15 → 20 → 30
head
data5next•
data10next•
data15next•
data20next•
tail
nullptrdata30next•
INSERT_AT_POSITION.CPPC++ EXCERPT
Node* temp = head;for (int i = 1; i < position - 1 && temp != nullptr; i++) temp = temp->next; // temp = node before positionnewNode->next = temp->next; // 1. link forward firsttemp->next = newNode; // 2. then re-link tempif (newNode->next == nullptr) tail = newNode;
SECTION 02: DELETION
SLIDE 08 // DELETE FROM BEGINNING
deleteFromBeginning()
Delete the Front Node
Delete from Beginning
START5 → 10 → 15 → 20 → nullptr
AFTER deleteFromBeginning()10 → 15 → 20 → nullptr
Moving a pointer does not free memory — the old node must still be deleted.
STEP 1
Keep a handle: save the node being removed (5) so it can be freed later.
Node* temp = head
STEP 2
Advance head: head moves to node 10, which becomes the new first node.
head = head->next
STEP 3
Release the memory: free node 5, which is now unreachable from the list.
delete temp
EMPTY RESULT
Last node removed: if the list becomes empty, tail must be cleared too.
if (head == nullptr) tail = nullptr
BEFORE — head IS 5head / tail SET
head
data5next•
data10next•
data15next•
tail
nullptrdata20next•
STEPS 1 & 2 — SAVE 5, MOVE head TO 105 LEAVES THE LIST BUT IS NOT FREED YET
temp
data5next•
head
data10next•
data15next•
tail
nullptrdata20next•
AFTER — delete temp FREES NODE 510 → 15 → 20
head
data10next•
data15next•
tail
nullptrdata20next•
DELETE_FROM_BEGINNING.CPPC++ METHOD
void deleteFromBeginning() { if (head == nullptr) return; // nothing to delete Node* temp = head; // 1. keep the node being removed head = head->next; // 2. move head forward delete temp; // 3. release the heap memory if (head == nullptr) tail = nullptr;}
SECTION 02: DELETION
SLIDE 09 // DELETE AT END
deleteAtEnd()
Delete the Last Node
Delete at End
START10 → 15 → 20 → 30 → nullptr
AFTER deleteAtEnd()10 → 15 → 20 → nullptr
A singly linked list points one way, so we must walk to the node before the tail.
STEP 1
Find the predecessor: advance temp until the next node is the tail; temp stops at 20.
while (temp->next->next != nullptr)
STEP 2
Free the last node: release node 30.
delete temp->next
STEP 3
Terminate the chain: node 20's next now marks the end.
temp->next = nullptr
LAST STEP
Move tail: tail now identifies node 20 as the final node.
tail = temp
STEP 1 — TEMP STOPS AT 20PREDECESSOR OF THE TAIL
head
data10next•
data15next•
temp
data20next•
tail
nullptrdata30next•
STEP 2 — FREE NODE 30temp->next IS THE OLD TAIL
head
data10next•
data15next•
temp
data20next•
old tail
nullptrdata30next•
STEPS 3 & 4 — TERMINATE & MOVE tail10 → 15 → 20
head
data10next•
data15next•
tail
nullptrdata20next•
DELETE_AT_END.CPPC++ EXCERPT
Node* temp = head;while (temp->next->next != nullptr) // stop before the tail temp = temp->next;delete temp->next; // free the old tail nodetemp->next = nullptr; // terminate the chaintail = temp; // predecessor becomes new tail
SECTION 02: DELETION
SLIDE 10 // DELETE AT A POSITION
deleteAtPosition(3)
Delete in the Middle
Delete at a Position
START10 → 15 → 20 → 25 → nullptr
AFTER deleteAtPosition(3)10 → 15 → 25 → nullptr
STEP 1
Find the predecessor: walk pos - 1 steps from head; temp stops at node 15, the node before position 3.
temp = node at pos - 1
STEP 2
Identify the target: the node to remove is node 20.
toDelete = temp->next
STEP 3
Bypass the target: point node 15 directly at node 25.
temp->next = toDelete->next
STEP 4
Free the node: release node 20 and, if it was the tail, move tail back to temp.
delete toDelete
STEP 1 — TEMP STOPS AT 15POSITION 3 → PREDECESSOR IS 15
head
data10next•
temp
data15next•
data20next•
tail
nullptrdata25next•
STEPS 2 & 3 — BYPASS NODE 2015 NOW POINTS AT 25
head
data10next•
temp
data15next•
tail
nullptrdata25next•
bypassedNode 20 is no longer reachable —
toDelete
data20next•
delete toDelete frees it.AFTER — delete toDelete FREES 2010 → 15 → 25
head
data10next•
data15next•
tail
nullptrdata25next•
DELETE_AT_POSITION.CPPC++ EXCERPT
Node* temp = head;for (int i = 1; temp != nullptr && i < pos - 1; i++) temp = temp->next; // temp = node before positionNode* toDelete = temp->next; // the node being removedtemp->next = toDelete->next; // bypass the removed nodedelete toDelete; // release the heap memoryif (temp->next == nullptr) tail = temp;
SECTION 02: INSPECTION
SLIDE 11 // TRAVERSAL
traverse()
Walking the Chain
List Traversal
START ATtemp = head
ADVANCEtemp = temp->next
Repeat until the pointer reaches nullptr — that is the end of the list.
STEPTEMP POINTS ATOUTPUT SO FAR
Startnode 10 (head)
List: 10 →Step 1node 20
20 →Step 2node 30 (tail)
30 →Stopnullptr — loop ends
NULLTHE POINTER MOVES NODE BY NODESAME NODE, ONE STEP AT A TIME
head
data10next•
1stdata20next•
2ndtail
nullptrdata30next•
3rdTRAVERSE.CPPC++ METHOD
void traverse() { if (head == nullptr) { cout << "List is empty." << endl; return; } Node* temp = head; // start at the first node cout << "List: "; while (temp != nullptr) { // stop at the end marker cout << temp->data << " -> "; temp = temp->next; // step to the next node } cout << "NULL" << endl;}
CONSOLE OUTPUTFOR 10 → 20 → 30
List: 10 -> 20 -> 30 -> NULL
SECTION 02: INSPECTION
SLIDE 12 // SEARCHING
search(key)
Comparing Values
Searching the List
METHODsearch(key)
Compare the key with each node's data, one node at a time, until a match or nullptr.
FOUND
Successful search: on the list 5 → 10 → 15 → 20 → 30 the comparisons run 5, then 10, then 15 — the search reports the value and stops.
search(15)
NOT FOUND
Unsuccessful search: every node is compared, the pointer finally reaches nullptr, and the key is reported as missing.
search(99)
FOUND — search(15) STOPS AT THE MATCHEARLY RETURN
5 ≠ 15
data5next•
10 ≠ 15
data10next•
match
data15next•
data20next•
NOT FOUND — search(99) REACHES THE ENDEVERY NODE VISITED
≠ 99
data5next•
≠ 99
data10next•
≠ 99
data15next•
≠ 99
nullptrdata20next•
SEARCH.CPPC++ METHOD
void search(int key) { Node* temp = head; // start at the first node while (temp != nullptr) { if (temp->data == key) { // compare the current value cout << key << " found in the list." << endl; return; // match: report and stop } temp = temp->next; // otherwise keep looking } cout << key << " not found in the list." << endl;}
SECTION 02: ROBUSTNESS
SLIDE 13 // EDGE CASES
BOUNDARY CONDITIONS
Defensive Pointer Logic
Critical Edge Cases
Every method must guard the boundaries: an empty list, a single node, the first position, and positions that do not exist.
CASEWHAT GOES WRONGGUARD
Empty ListDereferencing
head crashes.if (head == nullptr) return;Single Node
tail is left dangling.head = tail = nullptr;Position 1There is no
pos - 1 node.if (pos == 1) { … }Invalid PositionThe walk runs past the end.
temp == nullptrSINGLE NODE — DELETE THE ONLY NODEBEFORE → AFTER
head + tail
data10next•
headnullptr
EMPTY LIST — INSERT THE FIRST NODEBEFORE → AFTER
headnullptr
afterhead + tail
data10next•
INVALID POSITION — temp REACHES nullptrGUARDED BEFORE DEREFERENCE
head
data10next•
tail
nullptrdata20next•
STOP CONDITIONThe loop checks
temp != nullptr, so the walk cannot dereference a null node.SECTION 02: IMPLEMENTATION
SLIDE 14 // C++ IMPLEMENTATION
class LinkedList
The Class Behind the Diagrams
C++ Implementation
The LinkedList class keeps a single head and tail; every method you have seen operates on the very same chain.
MEMBERS
Two private pointers: they are the only references into the list and are managed only by the class.
Node* head, tail
CONSTRUCTOR
Start empty: the constructor guarantees a well-defined empty state before any operation runs.
head = tail = nullptr
METHODS
insertAtBeginninginsertAtEndinsertAtPositiondeleteFromBeginningdeleteAtEnddeleteAtPositiontraversesearch8 operations
ONE CHAIN, SHARED BY EVERY METHODhead → 10 · tail → 30
head
data10next•
data20next•
tail
nullptrdata30next•
LINKEDLIST.HC++ EXCERPT
class LinkedList {private: Node* head; // first node of the list Node* tail; // last node of the listpublic: LinkedList() : head(nullptr), tail(nullptr) {} // start empty // insertAtBeginning · insertAtEnd · insertAtPosition // deleteFromBeginning · deleteAtEnd · deleteAtPosition // traverse · search};
EXCERPT NOTEMethod bodies are shown in full on the operation slides;
new allocates each node and delete releases it.SECTION 02: EXECUTION TRACE
SLIDE 15 // COMPLETE WALKTHROUGH
main() END TO END
End-to-End Program Trace
Complete Walkthrough
LIST AFTER EACH CALL — traverse() RUNS AFTER EVERY CHANGEFINAL: 10 → 20
| Call | List after | Output printed |
|---|---|---|
| insertAtEnd(10)(20)(30) | 10 → 20 → 30 | List: 10 → 20 → 30 → NULL |
| insertAtBeginning(5) | 5 → 10 → 20 → 30 | List: 5 → 10 → 20 → 30 → NULL |
| insertAtPosition(15, 3) | 5 → 10 → 15 → 20 → 30 | List: 5 → 10 → 15 → 20 → 30 → NULL |
| search(15) | unchanged | 15 found in the list. |
| search(99) | unchanged | 99 not found in the list. |
| deleteFromBeginning() | 10 → 15 → 20 → 30 | Deleted 5 from beginning. |
| deleteAtEnd() | 10 → 15 → 20 | Deleted 30 from end. |
| deleteAtPosition(2) | 10 → 20 | Deleted 15 from position 2. |
ACTUAL PROGRAM OUTPUTEXIT CODE: 0
=== Insert at End ===
List: 10 -> 20 -> 30 -> NULL
=== Insert at Beginning ===
List: 5 -> 10 -> 20 -> 30 -> NULL
=== Insert at Position 3 ===
List: 5 -> 10 -> 15 -> 20 -> 30 -> NULL
=== Search ===
15 found in the list.
99 not found in the list.
=== Delete from Beginning ===
Deleted 5 from beginning.
List: 10 -> 15 -> 20 -> 30 -> NULL
=== Delete from End ===
Deleted 30 from end.
List: 10 -> 15 -> 20 -> NULL
=== Delete from Position 2 ===
Deleted 15 from position 2.
List: 10 -> 20 -> NULL
List: 10 -> 20 -> 30 -> NULL
=== Insert at Beginning ===
List: 5 -> 10 -> 20 -> 30 -> NULL
=== Insert at Position 3 ===
List: 5 -> 10 -> 15 -> 20 -> 30 -> NULL
=== Search ===
15 found in the list.
99 not found in the list.
=== Delete from Beginning ===
Deleted 5 from beginning.
List: 10 -> 15 -> 20 -> 30 -> NULL
=== Delete from End ===
Deleted 30 from end.
List: 10 -> 15 -> 20 -> NULL
=== Delete from Position 2 ===
Deleted 15 from position 2.
List: 10 -> 20 -> NULL
FINAL STATE OF THE LISThead → 10 · tail → 20
head
data10next•
tail
nullptrdata20next•
SECTION 02: ACTIVE LEARNING
SLIDE 16 // PREDICT THE OUTPUT
STUDENT EXERCISE
Classroom Check
Predict the Output
Trace the three calls by hand before revealing the answer. Use only the pointer rules already covered.
STARTING LISThead → 10 · tail → 30
head
data10next•
data20next•
tail
nullptrdata30next•
EXERCISE.CPPRUN IN THIS ORDER
// Starting list: 10 -> 20 -> 30list.insertAtBeginning(5);list.insertAtPosition(15, 3);list.deleteAtEnd();
ANSWER HIDDEN
STEPWHAT THE CALL DOESLIST AFTER
1Prepend 5 at the front
5 → 10 → 20 → 302Splice 15 into position 3
5 → 10 → 15 → 20 → 303Delete the last node (30)
5 → 10 → 15 → 20ANSWER — REVEAL AFTER THE DISCUSSIONFINAL LIST
head
data5next•
data10next•
data15next•
tail
nullptrdata20next•
EXPECTED traverse() OUTPUTVERIFIED
List: 5 -> 10 -> 15 -> 20 -> NULL
SECTION 02: SYNTHESIS
SLIDE 17 // KEY TAKEAWAYS
SUMMARY
Lesson Synthesis
Key Takeaways
PRINCIPLEREMEMBER
InsertionAdds a node and changes links — no element is shifted.
DeletionReconnects the neighbours and frees the removed node with
delete.TraversalVisits nodes one by one until the pointer reaches
nullptr.SearchingCompares values node by node — a match returns early, a miss reaches the end.
headIdentifies the first node of the list.
tailIdentifies the last node of the list.
nullptrThe last node points to
nullptr, marking the end.ONE LAST LOOK AT THE COMPLETE CHAIN10 → 20 → 30 → nullptr
head
data10next•
data20next•
tail
nullptrdata30next•
WALK TOOPERATIONS
none
insertAtBeginning, deleteFromBeginning and insertAtEnd work on the ends directly.the predecessor
deleteAtEnd — links point one way, so the walk starts at head.the position
insertAtPosition and deleteAtPosition walk up to the position, then rewire.the whole chain
traverse and search follow next to the end.NEXTSection 03 continues on the same node-and-pointer foundation with new structures.