Linear Search Algorithm in DSA Typescript - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Linear Search on Array

What is the output of the following TypeScript code that performs a linear search for the number 7?

DSA Typescript

function linearSearch(arr: number[], target: number): number {
  for (let i = 0; i < arr.length; i++) {
    if (arr[i] === target) {
      return i;
    }
  }
  return -1;
}

const numbers = [3, 5, 7, 9, 11];
console.log(linearSearch(numbers, 7));

A -1

B 3

C 2

D 1

💡 Hint

Remember that array indexes start at 0.

The number 7 is at index 2 in the array [3, 5, 7, 9, 11]. The linear search returns the index where the target is found.

❓ Predict Output

intermediate

Linear Search Result When Target Not Found

What does the following code print when searching for 10 in the array?

DSA Typescript

function linearSearch(arr: number[], target: number): number {
  for (let i = 0; i < arr.length; i++) {
    if (arr[i] === target) {
      return i;
    }
  }
  return -1;
}

const numbers = [1, 3, 5, 7, 9];
console.log(linearSearch(numbers, 10));

A 0

B 5

C 4

D -1

💡 Hint

If the target is not in the array, what does the function return?

The function returns -1 when the target is not found in the array.

🔧 Debug

advanced

Find the Bug in Linear Search Implementation

The following code is intended to perform a linear search but does not work correctly. What is the bug?

DSA Typescript

function linearSearch(arr: number[], target: number): number {
  let i = 0;
  while (i <= arr.length) {
    if (arr[i] === target) {
      return i;
    }
    i++;
  }
  return -1;
}

A The variable i should be initialized to 1 instead of 0

B The loop condition should be i < arr.length, not i <= arr.length

C The target comparison should use != instead of ===

D The return value should be i + 1 instead of i

💡 Hint

Check the loop boundary to avoid accessing outside the array.

Using i <= arr.length causes an out-of-bounds access when i equals arr.length, which is invalid. The correct condition is i < arr.length.

🧠 Conceptual

advanced

Time Complexity of Linear Search

What is the worst-case time complexity of the linear search algorithm on an array of size n?

A O(n)

B O(log n)

C O(n log n)

D O(1)

💡 Hint

Think about how many elements might be checked in the worst case.

In the worst case, linear search checks every element once, so the time complexity is O(n).

🚀 Application

expert

Linear Search on a Linked List

Given a singly linked list, which of the following TypeScript code snippets correctly performs a linear search for a target value and returns true if found, false otherwise?

DSA Typescript

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

function linearSearchLinkedList(head: Node | null, target: number): boolean {
  // Fill in the correct code here
}

A

let current = head;
while (current !== null) {
  if (current.value === target) {
    return true;
  }
  current = current.next;
}
return false;

B

let current = head;
while (current.next !== null) {
  if (current.value === target) {
    return true;
  }
  current = current.next;
}
return false;

C

let current = head;
do {
  if (current.value === target) {
    return true;
  }
  current = current.next;
} while (current !== null);
return false;

D

let current = head;
while (current !== null) {
  if (current.next === target) {
    return true;
  }
  current = current.next;
}
return false;

💡 Hint

Remember to check the current node's value, not the next node's value.

Option A correctly iterates through the list checking each node's value and returns true if the target is found. Option A misses the last node because it stops when current.next is null. Option A causes an error if head is null because do-while runs at least once. Option A incorrectly compares current.next to target instead of current.value.