Doubly linked list in Data Structures Theory - Mini Project: Build & Apply

Building a Doubly Linked List

📖 Scenario: Imagine you want to organize a playlist of songs where you can easily move forward and backward through the list. A doubly linked list is a way to connect items so you can go in both directions.

🎯 Goal: You will build the basic structure of a doubly linked list by creating nodes, linking them forward and backward, and completing the list connections.

📋 What You'll Learn

Create a node structure with data, next, and previous links

Set up a doubly linked list with three nodes containing exact values

Link nodes forward and backward correctly

Complete the list by connecting the last node's next to None and the first node's previous to None

💡 Why This Matters

🌍 Real World

Doubly linked lists are used in music players, web browsers, and undo-redo features where moving forward and backward through items is needed.

💼 Career

Understanding doubly linked lists helps in software development roles that require efficient data navigation and manipulation.

1

Create three nodes with data values

Create three variables called node1, node2, and node3. Each should be a dictionary with keys 'data', 'next', and 'prev'. Set the 'data' values to 10, 20, and 30 respectively. Set 'next' and 'prev' to None for all three nodes.

Data Structures Theory

# Create node1, node2, and node3 dictionaries with data, next, and prev keys
# Your code here

Hint

Use dictionaries to represent each node with keys 'data', 'next', and 'prev'. Initialize 'next' and 'prev' as None.

2

Link the nodes forward

Set the 'next' key of node1 to node2, and the 'next' key of node2 to node3. Leave node3's 'next' as None.

Data Structures Theory

node1 = {'data': 10, 'next': None, 'prev': None}
node2 = {'data': 20, 'next': None, 'prev': None}
node3 = {'data': 30, 'next': None, 'prev': None}
# Link node1's next to node2 and node2's next to node3
# Your code here

Hint

Assign the 'next' key of node1 to node2, and the 'next' key of node2 to node3.

3

Link the nodes backward

Set the 'prev' key of node3 to node2, and the 'prev' key of node2 to node1. Leave node1's 'prev' as None.

Data Structures Theory

node1 = {'data': 10, 'next': None, 'prev': None}
node2 = {'data': 20, 'next': None, 'prev': None}
node3 = {'data': 30, 'next': None, 'prev': None}

node1['next'] = node2
node2['next'] = node3
# Link node3's prev to node2 and node2's prev to node1
# Your code here

Hint

Assign the 'prev' key of node3 to node2, and the 'prev' key of node2 to node1.

4

Complete the doubly linked list connections

Ensure that node1's 'prev' is None and node3's 'next' is None to mark the ends of the list.

Data Structures Theory

node1 = {'data': 10, 'next': None, 'prev': None}
node2 = {'data': 20, 'next': None, 'prev': None}
node3 = {'data': 30, 'next': None, 'prev': None}

node1['next'] = node2
node2['next'] = node3

node3['prev'] = node2
node2['prev'] = node1
# Set node1's prev to None and node3's next to None
# Your code here

Hint

Make sure the first node's 'prev' and the last node's 'next' are None to show the list ends.

Practice

1. What is a key feature of a doubly linked list compared to a singly linked list?

easy

A. It stores data in a fixed-size array

B. Nodes only link to the next node

C. Each node has links to both the previous and next nodes

D. It uses a stack structure internally

Solution

1. Step 1: Understand node links in doubly linked lists

   A doubly linked list node contains two links: one to the previous node and one to the next node.

2. Step 2: Compare with singly linked list

   A singly linked list node only has a link to the next node, not the previous one.

3. Final Answer:

   Each node has links to both the previous and next nodes -> Option C

4. Quick Check:

   Doubly linked list = two links per node [OK]

Hint: Remember: doubly means two links per node [OK]

Common Mistakes:

• Thinking nodes only link forward
• Confusing with arrays or stacks
• Assuming fixed size storage

2. Which of the following is the correct way to update links when inserting a new node newNode after a node current in a doubly linked list?

easy

A. newNode.next = current.next; newNode.prev = current; current.next.prev = newNode; current.next = newNode;

B. newNode.prev = current.next; newNode.next = current; current.prev = newNode; current.next = newNode;

C. current.next = newNode; newNode.next = current.prev; current.prev = newNode;

D. newNode.next = current.prev; newNode.prev = current.next; current.next = newNode;

Solution

1. Step 1: Set newNode's next and prev pointers

   newNode.next should point to current.next, and newNode.prev should point to current.

2. Step 2: Update surrounding nodes to link to newNode

   current.next.prev must point back to newNode, and current.next must point to newNode.

3. Final Answer:

   newNode.next = current.next; newNode.prev = current; current.next.prev = newNode; current.next = newNode; -> Option A

4. Quick Check:

   Update newNode links, then fix neighbors [OK]

Hint: Update new node links before neighbors [OK]

Common Mistakes:

• Mixing prev and next pointers
• Not updating current.next.prev
• Assigning pointers in wrong order

3. Consider the following doubly linked list nodes and code snippet:

Node1: data=10, prev=None, next=Node2
Node2: data=20, prev=Node1, next=Node3
Node3: data=30, prev=Node2, next=None

current = Node2
print(current.prev.data, current.data, current.next.data)

What will be the output?

medium

A. None 20 30

B. 30 20 10

C. 20 20 20

D. 10 20 30

Solution

1. Step 1: Identify current node and its neighbors

   current is Node2 with data 20; prev is Node1 with data 10; next is Node3 with data 30.

2. Step 2: Print data values of prev, current, and next nodes

   Output will be 10 (prev), 20 (current), 30 (next).

3. Final Answer:

   10 20 30 -> Option D

4. Quick Check:

   Prev, current, next data = 10, 20, 30 [OK]

Hint: Prev and next data surround current data [OK]

Common Mistakes:

• Confusing prev and next nodes
• Assuming None has data
• Printing node references instead of data

4. The following code attempts to delete a node current from a doubly linked list. What is the error?

current.prev.next = current.next
current.next.prev = current.prev
current = None

medium

A. It should only update current.prev.next, not current.next.prev

B. It does not handle the case when current is the head node

C. It should update current.next.next instead of current.prev.next

D. It incorrectly sets current to None instead of deleting

Solution

1. Step 1: Analyze pointer updates for deletion

   The code updates the previous node's next pointer and the next node's prev pointer to bypass current.

2. Step 2: Check edge cases for head or tail nodes

   If current is the head (no prev), current.prev is None, so current.prev.next causes an error.

3. Final Answer:

   It does not handle the case when current is the head node -> Option B

4. Quick Check:

   Deleting head needs special handling [OK]

Hint: Check for None before updating neighbors [OK]

Common Mistakes:

• Ignoring head or tail node cases
• Assuming current is always in middle
• Confusing which pointers to update

5. You want to reverse a doubly linked list by swapping the next and prev pointers of each node. Which of the following steps is correct to achieve this?

hard

A. For each node, swap its next and prev pointers, then move to the new prev node

B. For each node, swap its next and prev pointers, then move to the new next node

C. For each node, only swap next pointers and ignore prev pointers

D. For each node, set next to None and prev to head

Solution

1. Step 1: Swap next and prev pointers for each node

   Swapping next and prev reverses the direction of links.

2. Step 2: Move to the new prev node after swapping

   After swapping, the original next is now prev, so move to node.prev to continue.

3. Final Answer:

   For each node, swap its next and prev pointers, then move to the new prev node -> Option A

4. Quick Check:

   Swap links, then follow new prev to reverse [OK]

Hint: After swapping, move to node.prev to continue [OK]

Common Mistakes:

• Moving to node.next after swapping
• Swapping only one pointer
• Setting pointers to None incorrectly