Create and Initialize Doubly Linked List in DSA Go - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare a struct for a doubly linked list node.

DSA Go

type Node struct {
	value int
	prev *[1]
	next *Node
}

Drag options to blanks, or click blank then click option'

AElement

Bnode

CNode

DList

Attempts:

3 left

💡 Hint

Common Mistakes

Using lowercase 'node' which is undefined.

Using a different struct name like 'List' or 'Element' which does not match the struct.

The prev pointer should point to the same Node struct type, so *Node is correct.

2fill in blank

medium

Complete the code to initialize a new doubly linked list node with a value.

DSA Go

func NewNode(val int) *Node {
	return &Node{value: [1], prev: nil, next: nil}
}

Drag options to blanks, or click blank then click option'

Avalue

Bval

Cval.value

DNode

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'value' instead of 'val' which is undefined in this scope.

Trying to access val.value which is invalid because val is an int.

The function parameter is named val, so we assign value: val to initialize the node's value.

3fill in blank

hard

Fix the error in the code to link two nodes correctly in a doubly linked list.

DSA Go

func LinkNodes(first, second *Node) {
	first.next = [1]
	second.prev = first
}

Drag options to blanks, or click blank then click option'

Asecond

Bfirst

Cnil

DNode

Attempts:

3 left

💡 Hint

Common Mistakes

Setting first.next to first itself causes a cycle.

Setting first.next to nil breaks the link.

The first node's next pointer should point to the second node to link them.

4fill in blank

hard

Fill both blanks to create a function that inserts a new node after a given node.

DSA Go

func InsertAfter(node, newNode *Node) {
	newNode.prev = [1]
	newNode.next = [2]
	if node.next != nil {
		node.next.prev = newNode
	}
	node.next = newNode
}

Drag options to blanks, or click blank then click option'

Anode

BnewNode

Cnode.next

Dnil

Attempts:

3 left

💡 Hint

Common Mistakes

Swapping prev and next assignments.

Setting newNode.next to newNode or nil incorrectly.

The new node's prev points to the current node, and next points to current node's next.

5fill in blank

hard

Fill all three blanks to create a function that removes a node from the doubly linked list.

DSA Go

func RemoveNode(node *Node) {
	if node.prev != nil {
		node.prev.next = [1]
	}
	if node.next != nil {
		node.next.prev = [2]
	}
	node.prev = [3]
	node.next = nil
}

Drag options to blanks, or click blank then click option'

Anode.next

Bnode.prev

Cnil

Dnode

Attempts:

3 left

💡 Hint

Common Mistakes

Setting node.prev or node.next to itself instead of nil.

Not updating the neighboring nodes' pointers correctly.

To remove a node, link its previous node's next to its next node, and next node's prev to its prev node. Then clear node's prev and next.

Practice

1. What is the main purpose of a doubly linked list in data structures?

easy

A. To sort data automatically

B. To store data in a fixed-size array

C. To allow traversal in both forward and backward directions

D. To store data only in a single direction

Solution

1. Step 1: Understand doubly linked list structure

   A doubly linked list has nodes with pointers to both previous and next nodes.

2. Step 2: Identify traversal capability

   This structure allows moving forward and backward through the list easily.

3. Final Answer:

   To allow traversal in both forward and backward directions -> Option C

4. Quick Check:

   Doubly linked list = bidirectional traversal [OK]

Hint: Remember: doubly means two directions [OK]

Common Mistakes:

• Confusing doubly linked list with arrays
• Thinking it sorts data automatically
• Assuming it only moves forward

2. Which of the following Go code snippets correctly defines a node struct for a doubly linked list?

easy

A. type Node struct { data int; next *Node; prev *Node }

B. type Node struct { data int; next Node; prev Node }

C. type Node struct { data int; next *int; prev *int }

D. type Node struct { data int; next int; prev int }

Solution

1. Step 1: Check pointer usage for next and prev

   In Go, linked list nodes must use pointers to other nodes, so next and prev should be *Node.

2. Step 2: Verify data types

   Data is int, and next and prev are pointers to Node, matching type Node struct { data int; next *Node; prev *Node }.

3. Final Answer:

   type Node struct { data int; next *Node; prev *Node } -> Option A

4. Quick Check:

   Pointers for next and prev = type Node struct { data int; next *Node; prev *Node } [OK]

Hint: Use *Node for next and prev pointers [OK]

Common Mistakes:

• Using value types instead of pointers for next/prev
• Using wrong pointer types like *int
• Missing semicolons or commas (Go allows semicolons but usually uses new lines)

3. What will be the output of the following Go code that creates a doubly linked list with nodes 1, 2, 3 and prints forward traversal?

package main
import "fmt"
type Node struct {
  data int
  next *Node
  prev *Node
}
func main() {
  head := &Node{data: 1}
  second := &Node{data: 2}
  third := &Node{data: 3}
  head.next = second
  second.prev = head
  second.next = third
  third.prev = second
  current := head
  for current != nil {
    fmt.Print(current.data)
    if current.next != nil {
      fmt.Print(" -> ")
    }
    current = current.next
  }
  fmt.Println(" -> null")
}

medium

A. 3 -> 2 -> 1 -> null

B. null -> 1 -> 2 -> 3

C. 1 2 3 null

D. 1 -> 2 -> 3 -> null

Solution

1. Step 1: Understand list creation and linking

   Nodes 1, 2, 3 are linked forward: head.next = second, second.next = third.

2. Step 2: Trace forward traversal loop

   Starting at head, prints 1, then 2, then 3, each followed by ' -> ', ending with ' -> null'.

3. Final Answer:

   1 -> 2 -> 3 -> null -> Option D

4. Quick Check:

   Forward traversal prints nodes in order [OK]

Hint: Follow next pointers from head to print forward [OK]

Common Mistakes:

• Confusing forward and backward traversal
• Missing arrows in output
• Printing data without separators

4. Identify the error in the following Go code that tries to initialize a doubly linked list node:

type Node struct {
  data int
  next *Node
  prev *Node
}

func main() {
  node := Node{data: 10, next: nil, prev: nil}
  node.next.prev = &node
}

medium

A. prev pointer should not be assigned

B. node.next is nil, so node.next.prev causes a runtime panic

C. Syntax error: missing & before node initialization

D. data field must be a pointer

Solution

1. Step 1: Analyze node initialization

   node.next is set to nil, so node.next does not point to any node.

2. Step 2: Check node.next.prev assignment

   Accessing node.next.prev tries to dereference nil, causing runtime panic (nil pointer dereference).

3. Final Answer:

   node.next is nil, so node.next.prev causes a runtime panic -> Option B

4. Quick Check:

   Dereferencing nil pointer = runtime panic [OK]

Hint: Never access fields of nil pointers [OK]

Common Mistakes:

• Ignoring nil pointer dereference
• Thinking &node is needed for struct literal
• Confusing data type requirements

5. You want to create a doubly linked list in Go with nodes containing values 5, 10, 15, and 20. Which code snippet correctly initializes the list and sets all next and prev pointers properly?

hard

A. head := &Node{data: 5}
second := &Node{data: 10}
third := &Node{data: 15}
fourth := &Node{data: 20}
head.next = second
second.prev = head
second.next = third
third.prev = second
third.next = fourth
fourth.prev = third

B. head := Node{data: 5}
second := Node{data: 10}
third := Node{data: 15}
fourth := Node{data: 20}
head.next = &second
second.prev = &head
second.next = &third
third.prev = &second
third.next = &fourth
fourth.prev = &third

C. head := &Node{data: 5, next: &Node{data: 10, prev: head}}
head.next.next = &Node{data: 15, prev: head.next}
head.next.next.next = &Node{data: 20, prev: head.next.next}

D. head := &Node{data: 5}
head.next = &Node{data: 10, prev: head}
head.next.next = &Node{data: 15, prev: head.next}
head.next.next.next = &Node{data: 20, prev: head.next.next}
head.next.next.next.next = nil

Solution

1. Step 1: Check pointer usage and linking

   head := &Node{data: 5} second := &Node{data: 10} third := &Node{data: 15} fourth := &Node{data: 20} head.next = second second.prev = head second.next = third third.prev = second third.next = fourth fourth.prev = third uses pointers for all nodes and sets next and prev pointers explicitly and correctly.

2. Step 2: Verify all links are consistent

   Each node's next points forward, and prev points backward, matching doubly linked list rules.

3. Final Answer:

   Code snippet in Option A correctly initializes and links all nodes -> Option A

4. Quick Check:

   Proper pointer linking = head := &Node{data: 5} second := &Node{data: 10} third := &Node{data: 15} fourth := &Node{data: 20} head.next = second second.prev = head second.next = third third.prev = second third.next = fourth fourth.prev = third [OK]

Hint: Use pointers and set both next and prev for each node [OK]

Common Mistakes:

• Using value types instead of pointers for nodes
• Not setting prev pointers
• Incorrect nested initialization causing nil prev