Linear Search Algorithm in DSA Typescript - Execution Trace

Concept Flow - Linear Search Algorithm

Start at index 0

↓

Check if element at index == target?

No→Move to next index

↓

Index < array length?

No→Target not found

↓

Return index

Start from the first element, check each one until the target is found or the list ends.

Execution Sample

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;
}

Searches the array from start to end to find the target value and returns its index or -1 if not found.

Execution Table

Step	Operation	Index Checked	Element at Index	Target	Match?	Action	Result
1	Check element	0	4	3	No	Move to next index	Continue searching
2	Check element	1	2	3	No	Move to next index	Continue searching
3	Check element	2	3	3	Yes	Return index	Found at index 2

💡 Target found at index 2, search stops.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	Final
i	0	1	2	2	2
arr[i]	4	2	3	3	3
target	3	3	3	3	3
result	undefined	undefined	undefined	2	2

Key Moments - 3 Insights

Why does the search stop immediately when a match is found?

Because the algorithm returns the index as soon as arr[i] === target is true, as shown in step 3 of the execution_table.

What happens if the target is not in the array?

The loop completes without finding a match, and the function returns -1, indicating the target is not found (not shown here but implied after last index).

Why do we check each element one by one instead of jumping around?

Linear search checks elements sequentially because it does not assume the array is sorted, so it must check every element until it finds the target or reaches the end.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of 'i' when the target is found?

A 0

B 2

C 1

D 3

💡 Hint

Check the 'Index Checked' column in the row where 'Match?' is 'Yes'.

At which step does the algorithm decide to return the index?

A Step 3

B Step 2

C Step 1

D After the loop ends

💡 Hint

Look at the 'Action' column where it says 'Return index'.

If the target was 5 instead of 3, what would happen in the execution_table?

A The search would find the target at index 1.

B The search would stop at step 3 with a match.

C The search would continue until the end and return -1.

D The search would return index 0 immediately.

💡 Hint

Think about what happens when no element matches the target in the 'Match?' column.

Concept Snapshot

Linear Search Algorithm:
- Start at index 0
- Check each element sequentially
- If element == target, return index
- If end reached without match, return -1
- Works on unsorted arrays
- Simple but can be slow for large arrays

Full Transcript

Linear search starts at the first element of the array and checks each element one by one to see if it matches the target value. If a match is found, it returns the index immediately. If the search reaches the end without finding the target, it returns -1 to indicate the target is not present. This method works on any array, sorted or not, but can be slow if the array is large because it may need to check every element.

Practice

1. What is the main idea behind the Linear Search Algorithm?

easy

A. Divide the list into halves repeatedly to find the target

B. Check each element one by one until the target is found or list ends

C. Sort the list first then search using binary steps

D. Use a hash table to find the target instantly

Solution

1. Step 1: Understand linear search process

   Linear search checks each element in order, from start to end, to find the target.

2. Step 2: Compare with other search methods

   Binary search divides list, hash uses extra memory, but linear search is simple sequential check.

3. Final Answer:

   Check each element one by one until the target is found or list ends -> Option B

4. Quick Check:

   Linear search = sequential check [OK]

Hint: Linear search means checking items one by one [OK]

Common Mistakes:

• Confusing linear search with binary search
• Thinking linear search requires sorted list
• Assuming linear search is always fastest

2. Which of the following is the correct TypeScript syntax to start a linear search loop over an array arr?

easy

A. for (let i = 0; i < arr.length; i++)

B. for (let i = 1; i <= arr.length; i++)

C. for (let i = 0; i <= arr.length; i++)

D. for (let i = 1; i < arr.length; i++)

Solution

1. Step 1: Identify correct loop start and end

   Array indices start at 0 and go up to length-1, so loop must start at 0 and run while i < length.

2. Step 2: Check each option's loop condition

   for (let i = 0; i < arr.length; i++) uses i=0 and i < arr.length, which is correct. Others either start at 1 or use <= which causes out-of-bounds.

3. Final Answer:

   for (let i = 0; i < arr.length; i++) -> Option A

4. Quick Check:

   Loop from 0 to length-1 [OK]

Hint: Array loops start at 0 and run while less than length [OK]

Common Mistakes:

• Starting loop at 1 instead of 0
• Using <= instead of < causing index errors
• Confusing array length with last index

3. What will be the output of this TypeScript code?

const arr = [4, 7, 1, 9];
const target = 1;
let index = -1;
for (let i = 0; i < arr.length; i++) {
  if (arr[i] === target) {
    index = i;
    break;
  }
}
console.log(index);

medium

A. 1

B. -1

C. 2

D. 3

Solution

1. Step 1: Trace the loop and compare elements

   Check arr[0]=4 (not 1), arr[1]=7 (not 1), arr[2]=1 (match found), set index=2 and break loop.

2. Step 2: Output the index variable

   After loop, index is 2, so console.log prints 2.

3. Final Answer:

   2 -> Option C

4. Quick Check:

   Target found at index 2 [OK]

Hint: Stop at first match and print its index [OK]

Common Mistakes:

• Not breaking loop and returning last index
• Confusing index with value
• Assuming index starts at 1

4. Find the error in this linear search code snippet and choose the fix:

const arr = [5, 3, 8];
const target = 3;
let index = -1;
for (let i = 0; i <= arr.length; i++) {
  if (arr[i] === target) {
    index = i;
    break;
  }
}
console.log(index);

medium

A. Change loop condition to i < arr.length

B. Initialize index to 0 instead of -1

C. Remove the break statement

D. Change target to 5

Solution

1. Step 1: Identify loop boundary error

   The loop uses i <= arr.length, which causes i to reach arr.length, an invalid index (out of bounds).

2. Step 2: Fix loop condition to prevent out-of-bounds

   Changing condition to i < arr.length ensures i stays within valid indices 0 to length-1.

3. Final Answer:

   Change loop condition to i < arr.length -> Option A

4. Quick Check:

   Loop must run while i < length [OK]

Hint: Use < not <= for array index loops [OK]

Common Mistakes:

• Using <= causing runtime error
• Changing unrelated variables
• Removing break causing unnecessary iterations

5. You want to find the last occurrence of a target number in an array using linear search. Which modification to this code will achieve that?

const arr = [2, 5, 3, 5, 7];
const target = 5;
let index = -1;
for (let i = 0; i < arr.length; i++) {
  if (arr[i] === target) {
    index = i;
    break;
  }
}
console.log(index);

hard

A. Sort the array before searching

B. Add break after setting index to stop at first occurrence

C. Start loop from the end and break at first match

D. Remove the break statement to continue searching all elements

Solution

1. Step 1: Understand current code behavior

   The loop checks all elements; each time target matches, index updates to current i, so last match index remains after loop.

2. Step 2: Identify why removing break helps

   If break was present, loop would stop at first match. Removing break ensures full array is checked for last occurrence.

3. Final Answer:

   Remove the break statement to continue searching all elements -> Option D

4. Quick Check:

   Keep searching to find last occurrence [OK]

Hint: To find last occurrence, check all elements without break [OK]

Common Mistakes:

• Adding break stops search too early
• Sorting changes original order and index meaning
• Starting loop from end requires different logic