Node Structure and Pointer Design in DSA Typescript - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare a class property for the node's value.

DSA Typescript

class Node {
  value: [1];
  next: Node | null;

  constructor(value: number) {
    this.value = value;
    this.next = null;
  }
}

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

Astring

Bany

Cboolean

Dnumber

Attempts:

3 left

💡 Hint

Common Mistakes

Using string instead of number for the value type.

Using any which is too general.

The node's value is a number, so the property type should be number.

2fill in blank

medium

Complete the code to initialize the next pointer to null in the constructor.

DSA Typescript

class Node {
  value: number;
  next: Node | null;

  constructor(value: number) {
    this.value = value;
    this.next = [1];
  }
}

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

Anull

Bundefined

C0

Dthis

Attempts:

3 left

💡 Hint

Common Mistakes

Using undefined instead of null.

Assigning 0 or this which are incorrect.

The next pointer should start as null to indicate no next node.

3fill in blank

hard

Fix the error in the method to set the next node pointer.

DSA Typescript

class Node {
  value: number;
  next: Node | null;

  constructor(value: number) {
    this.value = value;
    this.next = null;
  }

  setNext(node: Node | null): void {
    this.next = [1];
  }
}

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

Anull

Bthis

Cnode

Dvalue

Attempts:

3 left

💡 Hint

Common Mistakes

Assigning this or value instead of node.

Assigning null always which breaks linking.

The method should assign the passed node parameter to this.next.

4fill in blank

hard

Fill both blanks to create a method that returns true if the node has a next node.

DSA Typescript

class Node {
  value: number;
  next: Node | null;

  constructor(value: number) {
    this.value = value;
    this.next = null;
  }

  hasNext(): boolean {
    return this.next [1] [2];
  }
}

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

A!==

B==

Cnull

Dundefined

Attempts:

3 left

💡 Hint

Common Mistakes

Using == instead of !== which reverses logic.

Comparing to undefined instead of null.

The method checks if this.next is not equal to null to confirm a next node exists.

5fill in blank

hard

Fill all three blanks to implement a method that inserts a new node after the current node.

DSA Typescript

class Node {
  value: number;
  next: Node | null;

  constructor(value: number) {
    this.value = value;
    this.next = null;
  }

  insertAfter(newNode: Node): void {
    newNode.next = this.[1];
    this.[2] = newNode;
  }
}

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

Anext

Bvalue

Dprev

Attempts:

3 left

💡 Hint

Common Mistakes

Using value or prev instead of next.

Not updating this.next to newNode.

The method sets newNode.next to the current node's next, then updates this.next to newNode.

Practice

1. What does the next pointer in a singly linked list node represent?

easy

A. It points to the previous node in the list

B. It stores the data value of the node

C. It holds the size of the list

D. It points to the next node in the list

Solution

1. Step 1: Understand the role of next in singly linked list

   The next pointer is used to link the current node to the following node in the list.

2. Step 2: Differentiate from other pointers

   Unlike prev which points backward, next always points forward to the next node.

3. Final Answer:

   It points to the next node in the list -> Option D

4. Quick Check:

   next pointer = next node [OK]

Hint: Remember: next means forward link in singly linked list [OK]

Common Mistakes:

• Confusing next with previous pointer
• Thinking next stores data instead of address
• Assuming next holds list size

2. Which of the following is the correct TypeScript syntax to define a node class with a data property and a next pointer?

easy

A. class Node { data: number; next: Node; constructor(data: number) { this.data = data; this.next = null; } }

B. class Node { data: number; next: Node | null; constructor(data: number) { this.data = data; this.next = null; } }

C. class Node { data: number; next: Node; constructor() { this.data = 0; this.next = null; } }

D. class Node { data: number; next: null; constructor(data: number) { this.data = data; this.next = null; } }

Solution

1. Step 1: Check property types and initialization

   The next pointer should allow null to represent the end of the list, so its type must be Node | null.

2. Step 2: Verify constructor assigns values correctly

   The constructor takes data and sets next to null initially.

3. Final Answer:

   class Node { data: number; next: Node | null; constructor(data: number) { this.data = data; this.next = null; } } -> Option B

4. Quick Check:

   Allow null for next pointer = class Node { data: number; next: Node | null; constructor(data: number) { this.data = data; this.next = null; } } [OK]

Hint: Next pointer must allow null to mark list end [OK]

Common Mistakes:

• Not allowing next to be null
• Forgetting to initialize next in constructor
• Using wrong types for next pointer

3. Given the following TypeScript code, what will be the output when printing the linked list data values?

class Node {
  data: number;
  next: Node | null;
  constructor(data: number) {
    this.data = data;
    this.next = null;
  }
}

const head = new Node(10);
head.next = new Node(20);
head.next.next = new Node(30);

let current = head;
const result: number[] = [];
while (current !== null) {
  result.push(current.data);
  current = current.next;
}
console.log(result);

medium

A. [10, 20, 30]

B. [10, 20]

C. [20, 30]

D. []

Solution

1. Step 1: Trace node creation and linking

   Nodes are created with data 10, 20, and 30. The next pointers link 10 -> 20 -> 30 -> null.

2. Step 2: Follow the while loop to collect data

   The loop starts at head (10), adds 10, moves to 20, adds 20, moves to 30, adds 30, then stops at null.

3. Final Answer:

   [10, 20, 30] -> Option A

4. Quick Check:

   Traverse all nodes = [10, 20, 30] [OK]

Hint: Traverse until next is null to collect all nodes [OK]

Common Mistakes:

• Stopping traversal too early
• Not linking nodes correctly
• Confusing data values with pointers

4. Identify the error in the following TypeScript code for a singly linked list node and fix it:

class Node {
  data: number;
  next: Node;
  constructor(data: number) {
    this.data = data;
    this.next = null;
  }
}

medium

A. Data property should be optional

B. The constructor should not assign null to next

C. The type of next should be 'Node | null' to allow null assignment

D. Class should not have a constructor

Solution

1. Step 1: Analyze the type of next pointer

   The next property is typed as Node but assigned null, which is invalid.

2. Step 2: Correct the type to allow null

   Change the type to Node | null so it can hold either a node or null.

3. Final Answer:

   The type of next should be 'Node | null' to allow null assignment -> Option C

4. Quick Check:

   Allow null in next type = The type of next should be 'Node | null' to allow null assignment [OK]

Hint: Next pointer must allow null for list end [OK]

Common Mistakes:

• Not allowing null in next type
• Removing constructor unnecessarily
• Making data optional without reason

5. You want to design a doubly linked list node in TypeScript that stores a number and has pointers to both previous and next nodes. Which of the following class definitions correctly implements this with proper pointer types and initialization?

hard

A. class Node { data: number; prev: Node | null; next: Node | null; constructor(data: number) { this.data = data; this.prev = null; this.next = null; } }

B. class Node { data: number; prev: Node; next: Node; constructor(data: number) { this.data = data; this.prev = null; this.next = null; } }

C. class Node { data: number; prev: Node | null; next: Node; constructor(data: number) { this.data = data; this.prev = null; this.next = null; } }

D. class Node { data: number; prev: null; next: null; constructor(data: number) { this.data = data; this.prev = null; this.next = null; } }

Solution

1. Step 1: Check pointer types for doubly linked list

   Both prev and next pointers must allow null to represent ends of the list.

2. Step 2: Verify constructor initializes pointers to null

   Constructor correctly sets prev and next to null initially.

3. Final Answer:

   class Node { data: number; prev: Node | null; next: Node | null; constructor(data: number) { this.data = data; this.prev = null; this.next = null; } } -> Option A

4. Quick Check:

   Doubly linked list pointers allow null = class Node { data: number; prev: Node | null; next: Node | null; constructor(data: number) { this.data = data; this.prev = null; this.next = null; } } [OK]

Hint: Both prev and next pointers must allow null [OK]

Common Mistakes:

• Not allowing null for prev or next
• Setting pointer types incorrectly
• Initializing pointers to wrong values