Node Structure and Pointer Design in DSA Typescript - Build from Scratch

Node Structure and Pointer Design

📖 Scenario: Imagine you are building a simple linked list to keep track of tasks in a to-do list app. Each task is a node that holds the task name and a pointer to the next task.

🎯 Goal: You will create a node structure with a pointer to the next node, then link two nodes together, and finally print the linked list to see the tasks in order.

📋 What You'll Learn

Create a class called Node with two properties: task (string) and next (Node or null).

Create two nodes with tasks: 'Buy groceries' and 'Clean room'.

Link the first node's next pointer to the second node.

Print the tasks in the linked list starting from the first node.

💡 Why This Matters

🌍 Real World

Linked lists are used in many apps to manage ordered data like tasks, playlists, or history where you need to move through items one by one.

💼 Career

Understanding node structures and pointers is fundamental for software developers working with data structures, memory management, and building efficient algorithms.

1

Create the Node class

Create a class called Node with a constructor that takes a string parameter task and sets this.task to it. Also, add a property next initialized to null.

DSA Typescript

// Define the Node class with task and next properties
// Your code here

Hint

Use class keyword to create the Node class. The next property should be of type Node | null and start as null.

2

Create two nodes with tasks

Create two variables called firstNode and secondNode. Assign firstNode to a new Node with task 'Buy groceries' and secondNode to a new Node with task 'Clean room'.

DSA Typescript

class Node {
    task: string;
    next: Node | null;

    constructor(task: string) {
        this.task = task;
        this.next = null;
    }
}

// Create firstNode and secondNode with given tasks
// Your code here

Hint

Use the new keyword to create instances of the Node class with the exact task strings.

3

Link the first node to the second node

Set the next property of firstNode to point to secondNode.

DSA Typescript

class Node {
    task: string;
    next: Node | null;

    constructor(task: string) {
        this.task = task;
        this.next = null;
    }
}

const firstNode = new Node('Buy groceries');
const secondNode = new Node('Clean room');

// Link firstNode's next to secondNode
// Your code here

Hint

Use dot notation to set firstNode.next equal to secondNode.

4

Print the linked list tasks

Write a while loop to start from firstNode and print each node's task property until the next pointer is null. Use console.log to print each task.

DSA Typescript

class Node {
    task: string;
    next: Node | null;

    constructor(task: string) {
        this.task = task;
        this.next = null;
    }
}

const firstNode = new Node('Buy groceries');
const secondNode = new Node('Clean room');

firstNode.next = secondNode;

// Print all tasks starting from firstNode
// Your code here

Hint

Use a variable to track the current node. Loop while it is not null. Print the task, then move to the next node.

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