---
title: "Doubly vs singly linked list"
subject: "Data Structure and Algorithm"
chapter: 4
key: "semester_4/data_structure_and_algorithm:doubly-vs-singly-linked"
source: https://www.bctengineer.com/q/semester_4/data_structure_and_algorithm/doubly-vs-singly-linked
site: BCT Engineering
---

# Doubly vs singly linked list

Data Structure and Algorithm · Chapter 4: Linked lists

- Asked in: 2069 Poush, 2 marks; 2068 Bhadra, 2 marks (asked 2 times)
- Video: [Data structures: Introduction to Doubly Linked List](https://www.youtube.com/watch?v=JdQeNxWCguQ) — mycodeschool
- Answer checked by Claude Opus 5.5 (high effort) on 2026-10-14
- Page: https://www.bctengineer.com/q/semester_4/data_structure_and_algorithm/doubly-vs-singly-linked
- Whole chapter: https://www.bctengineer.com/md/semester_4/data_structure_and_algorithm/chapter-4

## Question

How does doubly linked list differ from singly linked list?

## Short answer

Singly linked list has only a next pointer, allowing forward traversal; deletion of a node requires its predecessor. Doubly linked list has both prev and next, supports bidirectional traversal and direct O(1) deletion of a given node, but uses more memory and demands more pointer updates.

## Answer

| Basis | Singly linked list | Doubly linked list |
|---|---|---|
| Pointers per node | One (`next`) | Two (`prev`, `next`) |
| Traversal | Forward only | Forward and backward |
| Memory per node | Less | More (extra pointer) |
| Deleting a given node | Needs the previous node (O(n) to find) | Done directly, O(1) |
| Insert before a node | Needs previous node | Easy using `prev` |
| Complexity of code | Simple | More pointer changes, more complex |

A doubly linked list gives easier two-way movement at the cost of extra memory and more pointer updates.

## Check yourself

The answer's key points as multiple-choice questions, with the correct option and why.

1. How many pointers does a node of a doubly linked list have, compared with a singly linked list?
   A. Two (prev, next) versus one (next)
   B. One versus two
   C. Two versus two
   D. Three versus one
   Answer: A. The extra prev pointer is the main structural difference. (Key point: Pointers per node)

2. Why is deleting a given node faster in a doubly linked list?
   A. It needs no pointer changes
   B. prev gives the predecessor directly, so it is O(1)
   C. Nodes are stored contiguously
   D. The list is always sorted
   Answer: B. A singly list needs an O(n) search for the previous node. (Key point: Deleting a given node)

3. What is the price paid for two-way traversal?
   A. Slower random access only
   B. Inability to insert at the end
   C. More memory and more pointer updates
   D. Loss of the NULL terminator
   Answer: C. Extra pointer per node and more links to change each operation. (Key point: Cost of doubly list)

## Related in Data Structure and Algorithm

- [Singly vs doubly linked list](https://www.bctengineer.com/question.md?key=semester_4%2Fdata_structure_and_algorithm%3Asingly-vs-doubly-linked) — Data Structure and Algorithm, chapter 4
- [Doubly linked list: bank customer records](https://www.bctengineer.com/question.md?key=semester_4%2Fdata_structure_and_algorithm%3Adoubly-bank-customer) — Data Structure and Algorithm, chapter 4
- [Insert and delete before a node, singly linked](https://www.bctengineer.com/question.md?key=semester_4%2Fdata_structure_and_algorithm%3Asingly-insert-delete-before) — Data Structure and Algorithm, chapter 4
- [Insert and delete kth node in doubly linked list](https://www.bctengineer.com/question.md?key=semester_4%2Fdata_structure_and_algorithm%3Adoubly-insert-delete-kth) — Data Structure and Algorithm, chapter 4, asked 2×
- [Delete last node of doubly linked list](https://www.bctengineer.com/question.md?key=semester_4%2Fdata_structure_and_algorithm%3Adelete-end-node-doubly) — Data Structure and Algorithm, chapter 4
- [Doubly linked list advantages and disadvantages](https://www.bctengineer.com/question.md?key=semester_4%2Fdata_structure_and_algorithm%3Adoubly-linked-define-pros-cons) — Data Structure and Algorithm, chapter 4