0type Node struct { data int prev *Node next *Node } type DoublyLinkedList struct { head *Node } func (dll *DoublyLinkedList) Add(data int) { node := &Node{data: data, prev: nil, next: nil} if dll.head == nil { dll.head = node return } current := dll.head for current.next != nil { current = current.next } current.next = node node.prev = current } // Example: // dll := &DoublyLinkedList{} // dll.Add(5) // dll.Add(10)
| Step | Operation | Nodes in List | Pointer Changes | Visual State |
|---|---|---|---|---|
| 1 | Create new node with data=5 | None | node.prev = nil, node.next = nil | nil <- [5] -> nil |
| 2 | List empty? Yes, set head = node | [5] | head -> node | nil <- [5] -> nil |
| 3 | Create new node with data=10 | [5] | node.prev = nil, node.next = nil | nil <- [5] -> nil, nil <- [10] -> nil |
| 4 | List empty? No, traverse to last node (5) | [5] | current = node with data 5 | nil <- [5] -> nil, nil <- [10] -> nil |
| 5 | Set last_node.next = new node (10) | [5, 10] | 5.next -> 10 | nil <- [5] <-> [10] -> nil |
| 6 | Set new node.prev = last_node (5) | [5, 10] | 10.prev -> 5 | nil <- [5] <-> [10] -> nil |
| 7 | Done | [5, 10] | head -> 5, 5.next -> 10, 10.prev -> 5 | nil <- [5] <-> [10] -> nil |
| Variable | Start | After Step 1 | After Step 2 | After Step 3 | After Step 4 | After Step 5 | After Step 6 | Final |
|---|---|---|---|---|---|---|---|---|
| node (new) | nil | data=5, prev=nil, next=nil | data=5, prev=nil, next=nil | data=10, prev=nil, next=nil | data=10, prev=nil, next=nil | data=10, prev=nil, next=nil | data=10, prev=5, next=nil | data=10, prev=5, next=nil |
| head | nil | nil | points to node with data=5 | points to node with data=5 | points to node with data=5 | points to node with data=5 | points to node with data=5 | points to node with data=5 |
| current | nil | nil | nil | nil | points to node with data=5 | points to node with data=5 | points to node with data=5 | points to node with data=5 |
Doubly Linked List Node: - Has data, prev pointer, next pointer - prev points to previous node or nil - next points to next node or nil Adding node: - If empty, head = new node - Else, traverse to last node - Link last_node.next = new node - Link new_node.prev = last_node Allows forward and backward traversal
prev pointer in a doubly linked list node?prev pointerprev pointer specifically points to the node that comes before the current node in the list.prev pointer = previous node [OK]prev with next pointerprev stores dataprev marks list endnext and prev must be pointers to Node.*Node for both next and prev, which is correct. type Node struct { data int; next Node; prev Node } uses non-pointer types, which is incorrect. type Node struct { data int; next *int; prev *int } uses pointers to int, which is wrong. type Node struct { data int; next *Node; prev int } mixes pointer and int, which is invalid.type Node struct {
data int
next *Node
prev *Node
}
func printList(head *Node) {
for head != nil {
fmt.Print(head.data, " ")
head = head.next
}
fmt.Println()
}
func main() {
var head *Node
head = &Node{data: 1}
second := &Node{data: 2}
third := &Node{data: 3}
head.next = second
second.prev = head
second.next = third
third.prev = second
printList(head)
}func insertAtBeginning(head *Node, data int) *Node {
newNode := &Node{data: data}
newNode.next = head
head.prev = newNode
return newNode
}head.prev = newNode without checking if head is nil, which causes a runtime error if the list is empty.head.prev, the code should check if head != nil to avoid dereferencing nil pointer.next and prev pointers of each node. Which of the following code snippets correctly performs this reversal?next and prev pointers for each node, then moving to the original next node (which becomes prev after swap).current.prev (original next). It updates head to the last processed node. func reverse(head *Node) *Node {
current := head
var temp *Node
for current != nil {
temp = current.next
current.next = current.prev
current.prev = temp
current = current.prev
}
if temp != nil {
head = temp.prev
}
return head
} swaps pointers but moves current incorrectly and updates head wrongly.Pass the test and this pattern moves unknown strong while earning +1 Grip toward your certificate.