What is Searching in Array?

Searching in array means finding whether a specific value exists inside an array or not.

The value we want to find is usually called the target value, search key, or simply key.

For example, suppose we have an array of numbers:

numbers = [10, 20, 30, 40, 50]

If we want to search for 30, the program should check the array and tell us that 30 exists at index 2.

Target = 30
Found at index = 2

Easy Real-Life Example

Searching in an array works in a similar way. The program checks array elements and tries to match them with the target value.

names = ["Aman", "Riya", "Sohan", "Meera"]

Search Target = "Sohan"

Result = Found at index 2

Why is Searching Needed?

Searching is one of the most common operations in programming because real-world applications often need to find data quickly.

Important Terms in Array Searching

Types of Searching in Array

There are many searching algorithms, but beginners usually start with two important methods:

Linear Search

Linear search is the simplest searching technique. It checks each element of the array one by one from the beginning to the end.

If the target value is found, the search stops and returns the index. If the target is not found after checking all elements, the result is not found.

Linear Search Steps

Linear Search Pseudocode

FUNCTION linearSearch(array, target)
    FOR index FROM 0 TO length(array) - 1
        IF array[index] == target THEN
            RETURN index
        END IF
    END FOR

    RETURN -1
END FUNCTION

Example 1: Linear Search in Number Array

/*
This program searches for a number using linear search.
*/

ENTRY POINT
    DECLARE numbers AS ARRAY = [10, 20, 30, 40, 50]
    DECLARE target AS INTEGER = 30
    DECLARE position AS INTEGER = -1

    FOR index FROM 0 TO length(numbers) - 1
        IF numbers[index] == target THEN
            SET position = index
            BREAK
        END IF
    END FOR

    IF position != -1 THEN
        DISPLAY target + " found at index " + position
    ELSE
        DISPLAY target + " not found"
    END IF
END ENTRY POINT

Expected Output

30 found at index 2

Example 2: Linear Search in Text Array

/*
This program searches for a student name in an array.
*/

ENTRY POINT
    DECLARE names AS ARRAY = ["Aman", "Riya", "Sohan", "Meera"]
    DECLARE targetName AS TEXT = "Sohan"
    DECLARE isFound AS BOOLEAN = false

    FOR index FROM 0 TO length(names) - 1
        IF names[index] == targetName THEN
            SET isFound = true
            DISPLAY targetName + " found at index " + index
            BREAK
        END IF
    END FOR

    IF isFound == false THEN
        DISPLAY targetName + " not found"
    END IF
END ENTRY POINT

Expected Output

Sohan found at index 2

Linear Search Trace Table

Suppose we search for 40 in the array:

numbers = [10, 20, 30, 40, 50]
target = 40

The target 40 is found at index 3.

Linear Search Complexity

Binary Search

Binary search is a faster searching technique, but it works only when the array is sorted.

Binary search checks the middle element first. If the target is smaller than the middle value, it searches the left half. If the target is greater than the middle value, it searches the right half.

Binary Search Steps

Binary Search Pseudocode

FUNCTION binarySearch(array, target)
    DECLARE low AS INTEGER = 0
    DECLARE high AS INTEGER = length(array) - 1

    WHILE low <= high DO
        DECLARE middle AS INTEGER = (low + high) DIV 2

        IF array[middle] == target THEN
            RETURN middle
        ELSE IF target < array[middle] THEN
            SET high = middle - 1
        ELSE
            SET low = middle + 1
        END IF
    END WHILE

    RETURN -1
END FUNCTION

Example 3: Binary Search in Sorted Array

/*
This program searches for a number using binary search.
The array must be sorted.
*/

ENTRY POINT
    DECLARE numbers AS ARRAY = [10, 20, 30, 40, 50, 60, 70]
    DECLARE target AS INTEGER = 50

    DECLARE low AS INTEGER = 0
    DECLARE high AS INTEGER = length(numbers) - 1
    DECLARE position AS INTEGER = -1

    WHILE low <= high DO
        DECLARE middle AS INTEGER = (low + high) DIV 2

        IF numbers[middle] == target THEN
            SET position = middle
            BREAK
        ELSE IF target < numbers[middle] THEN
            SET high = middle - 1
        ELSE
            SET low = middle + 1
        END IF
    END WHILE

    IF position != -1 THEN
        DISPLAY target + " found at index " + position
    ELSE
        DISPLAY target + " not found"
    END IF
END ENTRY POINT

Expected Output

50 found at index 4

Binary Search Trace Table

Suppose we search for 50 in the sorted array:

numbers = [10, 20, 30, 40, 50, 60, 70]
target = 50

Binary Search Complexity

Linear Search vs Binary Search

When to Use Which Search?

Example 4: Search and Return True or False

/*
This function returns true if target exists, otherwise false.
*/

FUNCTION containsValue(array, target)
    FOR index FROM 0 TO length(array) - 1
        IF array[index] == target THEN
            RETURN true
        END IF
    END FOR

    RETURN false
END FUNCTION

ENTRY POINT
    DECLARE numbers AS ARRAY = [5, 10, 15, 20]
    DECLARE result AS BOOLEAN = containsValue(numbers, 15)

    IF result == true THEN
        DISPLAY "Value exists"
    ELSE
        DISPLAY "Value does not exist"
    END IF
END ENTRY POINT

Expected Output

Value exists

Example 5: Count Occurrences of a Value

Sometimes, the target value may appear multiple times in an array. In that case, we can count how many times it appears.

/*
This program counts how many times a target value appears.
*/

ENTRY POINT
    DECLARE numbers AS ARRAY = [10, 20, 10, 30, 10, 40]
    DECLARE target AS INTEGER = 10
    DECLARE count AS INTEGER = 0

    FOR index FROM 0 TO length(numbers) - 1
        IF numbers[index] == target THEN
            SET count = count + 1
        END IF
    END FOR

    DISPLAY target + " appears " + count + " times"
END ENTRY POINT

Expected Output

10 appears 3 times

Common Beginner Mistakes

Best Practices for Searching in Array

Prerequisites Before Learning Searching in Array

Students should understand the following topics before learning array searching:

Practice Activity: Predict the Output

Predict the output of the following pseudocode.

numbers = [4, 8, 15, 16, 23, 42]
target = 16
position = -1

FOR index FROM 0 TO length(numbers) - 1
    IF numbers[index] == target THEN
        SET position = index
        BREAK
    END IF
END FOR

DISPLAY position

Your Answer

Output:
________________________

Sample Answer

3

Mini Quiz

Interview Questions on Searching in Array

Quick Summary