Find first and last positions of an element in a sorted array

Given a sorted array arr[] with possibly duplicate elements, the task is to find indexes of the first and last occurrences of an element x in the given array. 

Examples:

Input : arr[] = {1, 3, 5, 5, 5, 5, 67, 123, 125}, x = 5
Output : First Occurrence = 2
              Last Occurrence = 5

Input : arr[] = {1, 3, 5, 5, 5, 5, 7, 123, 125 }, x = 7

Output : First Occurrence = 6
              Last Occurrence = 6

A Naive Approach:

The idea to solve this problem is iterate on the elements of given array and check given elements in an array and keep track of first and last occurrence of the found element’s index.

Below are the steps to implement the above idea:

• Run a for loop and for i = 0 to n-1
• Take first = -1 and last = -1 
• When we find an element first time then we update first = i 
• We always update last=i whenever we find the element.
• We print first and last.

Below is the implementation of the above approach:

C++

// C++ program to find first and last occurrence of
// an elements in given sorted array
#include <bits/stdc++.h>
using namespace std;

// Function for finding first and last occurrence
// of an elements
void findFirstAndLast(int arr[], int n, int x)
{
    int first = -1, last = -1;
    for (int i = 0; i < n; i++) {
        if (x != arr[i])
            continue;
        if (first == -1)
            first = i;
        last = i;
    }
    if (first != -1)
        cout << "First Occurrence = " << first
             << "\nLast Occurrence = " << last;
    else
        cout << "Not Found";
}

// Driver code
int main()
{
    int arr[] = { 1, 2, 2, 2, 2, 3, 4, 7, 8, 8 };
    int n = sizeof(arr) / sizeof(int);
    int x = 8;
    findFirstAndLast(arr, n, x);
    return 0;
}

// This code is contributed by Aditya Kumar (adityakumar129)

C

// C program to find first and last occurrence of
// an elements in given sorted array
#include <stdio.h>

// Function for finding first and last occurrence
// of an elements
void findFirstAndLast(int arr[], int n, int x)
{
    int first = -1, last = -1;
    for (int i = 0; i < n; i++) {
        if (x != arr[i])
            continue;
        if (first == -1)
            first = i;
        last = i;
    }
    if (first != -1)
        printf(
            "First Occurrence = %d \nLast Occurrence = %d",
            first, last);
    else
        printf("Not Found");
}

// Driver code
int main()
{
    int arr[] = { 1, 2, 2, 2, 2, 3, 4, 7, 8, 8 };
    int n = sizeof(arr) / sizeof(int);
    int x = 8;
    findFirstAndLast(arr, n, x);
    return 0;
}

// This code is contributed by Aditya Kumar (adityakumar129)

Java

// Java program to find first and last occurrence of
// an elements in given sorted array
import java.io.*;

class GFG {
    // Function for finding first and last occurrence
    // of an elements
    public static void findFirstAndLast(int arr[], int x)
    {
        int n = arr.length;
        int first = -1, last = -1;
        for (int i = 0; i < n; i++) {
            if (x != arr[i])
                continue;
            if (first == -1)
                first = i;
            last = i;
        }
        if (first != -1) {
            System.out.println("First Occurrence = "
                               + first);
            System.out.println("Last Occurrence = " + last);
        }
        else
            System.out.println("Not Found");
    }

    public static void main(String[] args)
    {
        int arr[] = { 1, 2, 2, 2, 2, 3, 4, 7, 8, 8 };
        int x = 8;
        findFirstAndLast(arr, x);
    }
}

// This code is contributed by Aditya Kumar (adityakumar129)

Python3

# Python 3 program to find first and
# last occurrence of an elements in
# given sorted array


# Function for finding first and last
# occurrence of an elements
def findFirstAndLast(arr, n, x):
    first = -1
    last = -1
    for i in range(0, n):
        if (x != arr[i]):
            continue
        if (first == -1):
            first = i
        last = i

    if (first != -1):
        print("First Occurrence = ", first,
              " \nLast Occurrence = ", last)
    else:
        print("Not Found")


# Driver code
arr = [1, 2, 2, 2, 2, 3, 4, 7, 8, 8]
n = len(arr)
x = 8
findFirstAndLast(arr, n, x)


# This code is contributed by Nikita Tiwari.

C#

// C# program to find first and last
// occurrence of an elements in given
// sorted array
using System;

class GFG {

    // Function for finding first and
    // last occurrence of an elements
    static void findFirstAndLast(int[] arr, int x)
    {
        int n = arr.Length;
        int first = -1, last = -1;

        for (int i = 0; i < n; i++) {
            if (x != arr[i])
                continue;
            if (first == -1)
                first = i;
            last = i;
        }
        if (first != -1) {
            Console.WriteLine("First "
                              + "Occurrence = " + first);
            Console.Write("Last "
                          + "Occurrence = " + last);
        }
        else
            Console.Write("Not Found");
    }

    // Driver code
    public static void Main()
    {
        int[] arr = { 1, 2, 2, 2, 2, 3, 4, 7, 8, 8 };
        int x = 8;
        findFirstAndLast(arr, x);
    }
}

// This code is contributed by nitin mittal.

PHP

<?php
// PHP program to find first and last
// occurrence of an elements in given
// sorted array

// Function for finding first and last
// occurrence of an elements
function findFirstAndLast( $arr, $n, $x)
{
    $first = -1; $last = -1;
    for ( $i = 0; $i < $n; $i++)
    {
        if ($x != $arr[$i])
            continue;
        if ($first == -1)
            $first = $i;
        $last = $i;
    }
    if ($first != -1)
        echo "First Occurrence = ", $first,
              "\n", "\nLast Occurrence = ",
                                     $last;
    else
        echo "Not Found";
}

// Driver code
    $arr = array(1, 2, 2, 2, 2, 3, 4,
                                 7, 8, 8 );
    $n = count($arr);
    $x = 8;

    findFirstAndLast($arr, $n, $x);

// This code is contributed by anuj_67.
?>

Javascript

<script>
// Javascript program to find first and last occurrence of
// an elements in given sorted array

    // Function for finding first and last occurrence
    // of an elements
    function findFirstAndLast(arr,x)
    {
        let n = arr.length;
        let first = -1, last = -1;
        for (let i = 0; i < n; i++) {
            if (x != arr[i])
                continue;
            if (first == -1)
                first = i;
            last = i;
        }
        if (first != -1) {
            document.write("First Occurrence = " + first + "<br>");
            document.write("Last Occurrence = " + last + "<br>");
        }
        else
            document.write("Not Found");
    }

    let arr = [1, 2, 2, 2, 2, 3, 4, 7, 8, 8 ];
    let x = 8;
    findFirstAndLast(arr, x);

    // This code is contributed by avanitrachhadiya2155
</script>

Output

First Occurrence = 8
Last Occurrence = 9

Time Complexity: O(n) 
Auxiliary Space: O(1)

An efficient approach using binary search: 

1. For the first occurrence of a number 

a) If (high >= low)
b) Calculate  mid = low + (high – low)/2;
c) If ((mid == 0 || x > arr[mid-1]) && arr[mid] == x)
        return mid;
d) Else if (x > arr[mid])
       return first(arr, (mid + 1), high, x, n);
e) Else
       return first(arr, low, (mid -1), x, n);
f) Otherwise return -1;

2. For the last occurrence of a number 

a) if (high >= low)
b) calculate mid = low + (high – low)/2;
c)if( ( mid == n-1 || x < arr[mid+1]) && arr[mid] == x )
        return mid;
d) else if(x < arr[mid])
       return last(arr, low, (mid -1), x, n);
e) else
      return last(arr, (mid + 1), high, x, n);      
f) otherwise return -1;

Below is the implementation of the above approach:

C++

// C++ program to find first and last occurrences of
// a number in a given sorted array
#include <bits/stdc++.h>
using namespace std;

/* if x is present in arr[] then returns the index of
   FIRST occurrence of x in arr[0..n-1], otherwise
   returns -1 */
int first(int arr[], int low, int high, int x, int n)
{
    if (high >= low) {
        int mid = low + (high - low) / 2;
        if ((mid == 0 || x > arr[mid - 1]) && arr[mid] == x)
            return mid;
        else if (x > arr[mid])
            return first(arr, (mid + 1), high, x, n);
        else
            return first(arr, low, (mid - 1), x, n);
    }
    return -1;
}

/* if x is present in arr[] then returns the index of
   LAST occurrence of x in arr[0..n-1], otherwise
   returns -1 */
int last(int arr[], int low, int high, int x, int n)
{
    if (high >= low) {
        int mid = low + (high - low) / 2;
        if ((mid == n - 1 || x < arr[mid + 1])
            && arr[mid] == x)
            return mid;
        else if (x < arr[mid])
            return last(arr, low, (mid - 1), x, n);
        else
            return last(arr, (mid + 1), high, x, n);
    }
    return -1;
}

// Driver program
int main()
{
    int arr[] = { 1, 2, 2, 2, 2, 3, 4, 7, 8, 8 };
    int n = sizeof(arr) / sizeof(int);

    int x = 8;
    printf("First Occurrence = %d\t",
           first(arr, 0, n - 1, x, n));
    printf("\nLast Occurrence = %d\n",
           last(arr, 0, n - 1, x, n));
    return 0;
}

// This code is contributed by Sania Kumari Gupta
// (kriSania804)

C

// C program to find first and last occurrences of
// a number in a given sorted array
#include <stdio.h>

/* if x is present in arr[] then returns the index of
   FIRST occurrence of x in arr[0..n-1], otherwise
   returns -1 */
int first(int arr[], int low, int high, int x, int n)
{
    if (high >= low) {
        int mid = low + (high - low) / 2;
        if ((mid == 0 || x > arr[mid - 1]) && arr[mid] == x)
            return mid;
        else if (x > arr[mid])
            return first(arr, (mid + 1), high, x, n);
        else
            return first(arr, low, (mid - 1), x, n);
    }
    return -1;
}

/* if x is present in arr[] then returns the index of
   LAST occurrence of x in arr[0..n-1], otherwise
   returns -1 */
int last(int arr[], int low, int high, int x, int n)
{
    if (high >= low) {
        int mid = low + (high - low) / 2;
        if ((mid == n - 1 || x < arr[mid + 1])
            && arr[mid] == x)
            return mid;
        else if (x < arr[mid])
            return last(arr, low, (mid - 1), x, n);
        else
            return last(arr, (mid + 1), high, x, n);
    }
    return -1;
}

// Driver program
int main()
{
    int arr[] = { 1, 2, 2, 2, 2, 3, 4, 7, 8, 8 };
    int n = sizeof(arr) / sizeof(int);

    int x = 8;
    printf("First Occurrence = %d\t",
           first(arr, 0, n - 1, x, n));
    printf("\nLast Occurrence = %d\n",
           last(arr, 0, n - 1, x, n));

    return 0;
}

// This code is contributed by Sania Kumari Gupta
// (kriSania804)

Java

// Java program to find first and last occurrence of
// an elements in given sorted array
import java.io.*;

class GFG {
    /* if x is present in arr[] then returns the index of
    FIRST occurrence of x in arr[0..n-1], otherwise
    returns -1 */
    public static int first(int arr[], int low, int high,
                            int x, int n)
    {
        if (high >= low) {
            int mid = low + (high - low) / 2;
            if ((mid == 0 || x > arr[mid - 1])
                && arr[mid] == x)
                return mid;
            else if (x > arr[mid])
                return first(arr, (mid + 1), high, x, n);
            else
                return first(arr, low, (mid - 1), x, n);
        }
        return -1;
    }

    /* if x is present in arr[] then returns the index of
    LAST occurrence of x in arr[0..n-1], otherwise
    returns -1 */
    public static int last(int arr[], int low, int high,
                           int x, int n)
    {
        if (high >= low) {
            int mid = low + (high - low) / 2;
            if ((mid == n - 1 || x < arr[mid + 1])
                && arr[mid] == x)
                return mid;
            else if (x < arr[mid])
                return last(arr, low, (mid - 1), x, n);
            else
                return last(arr, (mid + 1), high, x, n);
        }
        return -1;
    }

    public static void main(String[] args)
    {

        int arr[] = { 1, 2, 2, 2, 2, 3, 4, 7, 8, 8 };
        int n = arr.length;
        int x = 8;
        System.out.println("First Occurrence = "
                           + first(arr, 0, n - 1, x, n));
        System.out.println("Last Occurrence = "
                           + last(arr, 0, n - 1, x, n));
    }
}

Python3

# Python 3 program to find first and
# last occurrences of a number in
# a given sorted array

# if x is present in arr[] then
# returns the index of FIRST
# occurrence of x in arr[0..n-1],
# otherwise returns -1


def first(arr, low, high, x, n):
    if(high >= low):
        mid = low + (high - low) // 2
        if((mid == 0 or x > arr[mid - 1]) and arr[mid] == x):
            return mid
        elif(x > arr[mid]):
            return first(arr, (mid + 1), high, x, n)
        else:
            return first(arr, low, (mid - 1), x, n)

    return -1


# if x is present in arr[] then
# returns the index of LAST occurrence
# of x in arr[0..n-1], otherwise
# returns -1
def last(arr, low, high, x, n):
    if (high >= low):
        mid = low + (high - low) // 2
        if ((mid == n - 1 or x < arr[mid + 1]) and arr[mid] == x):
            return mid
        elif (x < arr[mid]):
            return last(arr, low, (mid - 1), x, n)
        else:
            return last(arr, (mid + 1), high, x, n)

    return -1


# Driver program
arr = [1, 2, 2, 2, 2, 3, 4, 7, 8, 8]
n = len(arr)

x = 8
print("First Occurrence = ",
      first(arr, 0, n - 1, x, n))
print("Last Occurrence = ",
      last(arr, 0, n - 1, x, n))


# This code is contributed by Nikita Tiwari.

C#

// C# program to find first and last occurrence
// of an elements in given sorted array
using System;

class GFG {

    /* if x is present in arr[] then
    returns the index of FIRST
    occurrence of x in arr[0..n-1],
    otherwise returns -1 */
    public static int first(int[] arr, int low, int high,
                            int x, int n)
    {
        if (high >= low) {
            int mid = low + (high - low) / 2;

            if ((mid == 0 || x > arr[mid - 1])
                && arr[mid] == x)
                return mid;
            else if (x > arr[mid])
                return first(arr, (mid + 1), high, x, n);
            else
                return first(arr, low, (mid - 1), x, n);
        }

        return -1;
    }

    /* if x is present in arr[] then returns
    the index of LAST occurrence of x in
    arr[0..n-1], otherwise returns -1 */
    public static int last(int[] arr, int low, int high,
                           int x, int n)
    {
        if (high >= low) {
            int mid = low + (high - low) / 2;

            if ((mid == n - 1 || x < arr[mid + 1])
                && arr[mid] == x)
                return mid;
            else if (x < arr[mid])
                return last(arr, low, (mid - 1), x, n);
            else
                return last(arr, (mid + 1), high, x, n);
        }

        return -1;
    }

    // Driver code
    public static void Main()
    {

        int[] arr = { 1, 2, 2, 2, 2, 3, 4, 7, 8, 8 };
        int n = arr.Length;
        int x = 8;
        Console.WriteLine("First Occurrence = "
                          + first(arr, 0, n - 1, x, n));

        Console.Write("Last Occurrence = "
                      + last(arr, 0, n - 1, x, n));
    }
}

// This code is contributed by nitin mittal.

PHP

<?php
// PHP program to find first
// and last occurrences of a
// number in a given sorted array

// if x is present in arr[] then
// returns the index of FIRST
// occurrence of x in arr[0..n-1],
// otherwise returns -1
function first($arr, $low, $high,
                          $x, $n)
{
    if($high >= $low)
    {
        $mid = floor($low + ($high - $low) / 2);
        if(($mid == 0 or $x > $arr[$mid - 1])
                        and $arr[$mid] == $x)
            return $mid;
        else if($x > $arr[$mid])
            return first($arr, ($mid + 1),
                           $high, $x, $n);
        else
            return first($arr, $low, ($mid - 1),
                                        $x, $n);
    }
    return -1;
}


// if x is present in arr[]
// then returns the index of
// LAST occurrence of x in
// arr[0..n-1], otherwise
// returns -1
function last($arr, $low, $high,
                        $x, $n)
{
    if ($high >= $low)
    {
        $mid = floor($low + ($high -
                         $low) / 2);
        if (( $mid == $n - 1 or $x <
            $arr[$mid + 1]) and
            $arr[$mid] == $x)
                return $mid;
        else if ($x < $arr[$mid])
            return last($arr, $low,
               ($mid - 1), $x, $n);
        else
            return last($arr, ($mid + 1),
                          $high, $x, $n);
    return -1;
    }
}

    // Driver Code
    $arr = array(1, 2, 2, 2, 2, 3, 4, 7, 8, 8);
    $n = count($arr);

    $x = 8;
    echo "First Occurrence = ",
          first($arr, 0, $n - 1, $x, $n), "\n";
    echo "Last Occurrence = ",
          last($arr, 0, $n - 1, $x, $n);

// This code is contributed by anuj_67
?>

Javascript

<script>

// JavaScript program to find first and last occurrences of
// a number in a given sorted array


/* if x is present in arr then returns the index of
   FIRST occurrence of x in arr[0..n-1], otherwise
   returns -1 */
 function first(arr,low,high,x,n)
{
    if (high >= low) {
        let mid = low + Math.floor((high - low) / 2);
        if ((mid == 0 || x > arr[mid - 1]) && arr[mid] == x)
            return mid;
        else if (x > arr[mid])
            return first(arr, (mid + 1), high, x, n);
        else
            return first(arr, low, (mid - 1), x, n);
    }
    return -1;
}

/* if x is present in arr then returns the index of
   LAST occurrence of x in arr[0..n-1], otherwise
   returns -1 */
function last(arr, low, high, x, n)
{
    if (high >= low) {
        let mid = low + Math.floor((high - low) / 2);
        if ((mid == n - 1 || x < arr[mid + 1]) && arr[mid] == x)
            return mid;
        else if (x < arr[mid])
            return last(arr, low, (mid - 1), x, n);
        else
            return last(arr, (mid + 1), high, x, n);
    }
    return -1;
}

// Driver program

    let arr = [ 1, 2, 2, 2, 2, 3, 4, 7, 8, 8 ];
    let n = arr.length;

    let x = 8;
    document.write("First Occurrence = " + first(arr, 0, n - 1, x, n),"</br>");
    console.log("Last Occurrence = " + last(arr, 0, n - 1, x, n),"</br>");

// code is contributed by shinjanpatra

</script>

Output

First Occurrence = 8    
Last Occurrence = 9

Time Complexity: O(log n) 
Auxiliary Space: O(log n), for recursion call stack

An Iterative Implementation of Binary Search Solution :

1. For the first occurrence, we will first find the index of the number and then search again in the left subarray as long as we are finding the number.
   
2. For the last occurrence, we will first find the index of the number and then search again in the right subarray as long as we are finding the number

First occurrence: 

• Do while low <= high:
  • First, find the mid element
  • Check if the arr[mid] > x then the first element will occur on the left side of mid. So, bring the high pointer to mid – 1
  • Check if the arr[mid] < x then the first element will occur on the right side of mid. So, bring the low pointer to mid + 1
  • If arr[mid] == x then this may be the first element. So, update the result to mid and move the high pointer to mid – 1.
• Return the result.

Last occurrence: 

• Do while low <= high:
  • First, find the mid element
  • Check if the arr[mid] > x then the last element will occur on the left side of mid. So, bring the high pointer to mid – 1
  • Check if the arr[mid] < x then the last element will occur on the right side of mid. So, bring the low pointer to mid + 1
  • If arr[mid] == x then this may be the last element. So, update the result to mid and move the low pointer to mid + 1.
• Finally, Return the result.

C++

// C++ program to find first and last occurrences
// of a number in a given sorted array
#include <bits/stdc++.h>
using namespace std;

/* if x is present in arr[] then returns the
index of FIRST occurrence of x in arr[0..n-1],
otherwise returns -1 */
int first(int arr[], int x, int n)
{
    int low = 0, high = n - 1, res = -1;
    while (low <= high) {

        // Normal Binary Search Logic
        int mid = (low + high) / 2;

        if (arr[mid] > x)
            high = mid - 1;
        else if (arr[mid] < x)
            low = mid + 1;

        // If arr[mid] is same as x, we
        // update res and move to the left
        // half.
        else {
            res = mid;
            high = mid - 1;
        }
    }
    return res;
}

/* If x is present in arr[] then returns
the index of LAST occurrence of x in
arr[0..n-1], otherwise returns -1 */
int last(int arr[], int x, int n)
{
    int low = 0, high = n - 1, res = -1;
    while (low <= high) {

        // Normal Binary Search Logic
        int mid = (low + high) / 2;

        if (arr[mid] > x)
            high = mid - 1;
        else if (arr[mid] < x)
            low = mid + 1;

        // If arr[mid] is same as x, we
        // update res and move to the right
        // half.
        else {
            res = mid;
            low = mid + 1;
        }
    }
    return res;
}

// Driver code
int main()
{
    int arr[] = { 1, 2, 2, 2, 2, 3, 4, 7, 8, 8 };
    int n = sizeof(arr) / sizeof(int);

    int x = 8;
    cout << "First Occurrence = " << first(arr, x, n);
    cout << "\nLast Occurrence = " << last(arr, x, n);

    return 0;
}

// This code is contributed by shivanisinghss2110

C

// C program to find first and last occurrences of
// a number in a given sorted array
#include <stdio.h>

/* if x is present in arr[] then returns the index of
FIRST occurrence of x in arr[0..n-1], otherwise
returns -1 */
int first(int arr[], int x, int n)
{
    int low = 0, high = n - 1, res = -1;
    while (low <= high) {
        // Normal Binary Search Logic
        int mid = (low + high) / 2;
        if (arr[mid] > x)
            high = mid - 1;
        else if (arr[mid] < x)
            low = mid + 1;

        // If arr[mid] is same as x, we
        // update res and move to the left
        // half.
        else {
            res = mid;
            high = mid - 1;
        }
    }
    return res;
}

/* if x is present in arr[] then returns the index of
LAST occurrence of x in arr[0..n-1], otherwise
returns -1 */
int last(int arr[], int x, int n)
{
    int low = 0, high = n - 1, res = -1;
    while (low <= high) {
        // Normal Binary Search Logic
        int mid = (low + high) / 2;
        if (arr[mid] > x)
            high = mid - 1;
        else if (arr[mid] < x)
            low = mid + 1;

        // If arr[mid] is same as x, we
        // update res and move to the right
        // half.
        else {
            res = mid;
            low = mid + 1;
        }
    }
    return res;
}

// Driver program
int main()
{
    int arr[] = { 1, 2, 2, 2, 2, 3, 4, 7, 8, 8 };
    int n = sizeof(arr) / sizeof(int);

    int x = 8;
    printf("First Occurrence = %d\t", first(arr, x, n));
    printf("\nLast Occurrence = %d\n", last(arr, x, n));

    return 0;
}

Java

// Java program to find first
// and last occurrences of a
// number in a given sorted array
import java.util.*;
class GFG {

    // if x is present in arr[] then
    // returns the index of FIRST
    // occurrence of x in arr[0..n-1],
    // otherwise returns -1
    static int first(int arr[], int x, int n)
    {
        int low = 0, high = n - 1, res = -1;
        while (low <= high) {
            // Normal Binary Search Logic
            int mid = (low + high) / 2;
            if (arr[mid] > x)
                high = mid - 1;
            else if (arr[mid] < x)
                low = mid + 1;

            // If arr[mid] is same as
            // x, we update res and
            // move to the left half.
            else {
                res = mid;
                high = mid - 1;
            }
        }
        return res;
    }

    // If x is present in arr[] then returns
    // the index of LAST occurrence of x in
    // arr[0..n-1], otherwise returns -1
    static int last(int arr[], int x, int n)
    {
        int low = 0, high = n - 1, res = -1;
        while (low <= high) {
            // Normal Binary Search Logic
            int mid = (low + high) / 2;
            if (arr[mid] > x)
                high = mid - 1;
            else if (arr[mid] < x)
                low = mid + 1;

            // If arr[mid] is same as x,
            // we update res and move to
            // the right half.
            else {
                res = mid;
                low = mid + 1;
            }
        }
        return res;
    }

    // Driver program
    public static void main(String[] args)
    {
        int arr[] = { 1, 2, 2, 2, 2, 3, 4, 7, 8, 8 };
        int n = arr.length;
        int x = 8;
        System.out.println("First Occurrence = "
                           + first(arr, x, n));
        System.out.println("Last Occurrence = "
                           + last(arr, x, n));
    }
}

// This code is contributed by Chitranayal

Python3

# Python3 program to find first and
# last occurrences of a number in a
# given sorted array

# If x is present in arr[] then
# returns the index of FIRST
# occurrence of x in arr[0..n-1],
# otherwise returns -1


def first(arr, x, n):

    low = 0
    high = n - 1
    res = -1

    while (low <= high):

        # Normal Binary Search Logic
        mid = (low + high) // 2

        if arr[mid] > x:
            high = mid - 1
        elif arr[mid] < x:
            low = mid + 1

        # If arr[mid] is same as x, we
        # update res and move to the left
        # half.
        else:
            res = mid
            high = mid - 1

    return res

# If x is present in arr[] then returns
# the index of FIRST occurrence of x in
# arr[0..n-1], otherwise returns -1


def last(arr, x, n):

    low = 0
    high = n - 1
    res = -1

    while(low <= high):

        # Normal Binary Search Logic
        mid = (low + high) // 2

        if arr[mid] > x:
            high = mid - 1
        elif arr[mid] < x:
            low = mid + 1

        # If arr[mid] is same as x, we
        # update res and move to the Right
        # half.
        else:
            res = mid
            low = mid + 1

    return res


# Driver code
arr = [1, 2, 2, 2, 2, 3, 4, 7, 8, 8]
n = len(arr)
x = 8

print("First Occurrence =", first(arr, x, n))
print("Last Occurrence =", last(arr, x, n))

# This code is contributed by Ediga_Manisha.

C#

// C# program to find first
// and last occurrences of a
// number in a given sorted array
using System;
class GFG {

    // if x is present in []arr then
    // returns the index of FIRST
    // occurrence of x in arr[0..n-1],
    // otherwise returns -1
    static int first(int[] arr, int x, int n)
    {
        int low = 0, high = n - 1, res = -1;
        while (low <= high) {
            // Normal Binary Search Logic
            int mid = (low + high) / 2;
            if (arr[mid] > x)
                high = mid - 1;
            else if (arr[mid] < x)
                low = mid + 1;

            // If arr[mid] is same as
            // x, we update res and
            // move to the left half.
            else {
                res = mid;
                high = mid - 1;
            }
        }
        return res;
    }

    // If x is present in []arr then returns
    // the index of LAST occurrence of x in
    // arr[0..n-1], otherwise returns -1
    static int last(int[] arr, int x, int n)
    {
        int low = 0, high = n - 1, res = -1;
        while (low <= high) {
            // Normal Binary Search Logic
            int mid = (low + high) / 2;
            if (arr[mid] > x)
                high = mid - 1;
            else if (arr[mid] < x)
                low = mid + 1;

            // If arr[mid] is same as x,
            // we update res and move to
            // the right half.
            else {
                res = mid;
                low = mid + 1;
            }
        }
        return res;
    }

    // Driver program
    public static void Main(String[] args)
    {
        int[] arr = { 1, 2, 2, 2, 2, 3, 4, 7, 8, 8 };
        int n = arr.Length;
        int x = 8;
        Console.WriteLine("First Occurrence = "
                          + first(arr, x, n));
        Console.WriteLine("Last Occurrence = "
                          + last(arr, x, n));
    }
}

// This code is contributed by 29AjayKumar

Javascript

<script>

// JavaScript program to find first and last occurrences
// of a number in a given sorted array

/* if x is present in arr[] then returns the
index of FIRST occurrence of x in arr[0..n-1],
otherwise returns -1 */

function first(arr, x, n)
{
    let low = 0, high = n - 1, res = -1;
    while (low <= high)
    {

        // Normal Binary Search Logic
        let mid = Math.floor((low + high) / 2);

        if (arr[mid] > x)
            high = mid - 1;
        else if (arr[mid] < x)
            low = mid + 1;

        // If arr[mid] is same as x, we
        // update res and move to the left
        // half.
        else
        {
            res = mid;
            high = mid - 1;
        }
    }
    return res;
}

/* If x is present in arr[] then returns
the index of LAST occurrence of x in
arr[0..n-1], otherwise returns -1 */
function last(arr, x, n)
{
    let low = 0, high = n - 1, res = -1;
    while (low <= high)
    {

        // Normal Binary Search Logic
        let mid = Math.floor((low + high) / 2);

        if (arr[mid] > x)
            high = mid - 1;
        else if (arr[mid] < x)
            low = mid + 1;

        // If arr[mid] is same as x, we
        // update res and move to the right
        // half.
        else
        {
            res = mid;
            low = mid + 1;
        }
    }
    return res;
}

// Driver code

    let arr = [ 1, 2, 2, 2, 2, 3, 4, 7, 8, 8 ];
    let n = arr.length;

    let x = 8;
    document.write("First Occurrence = " + first(arr, x, n),"</br>");
    document.write("Last Occurrence = " + last(arr, x, n));


// This code is contributed by shinjanpatra

</script>

Output

First Occurrence = 8
Last Occurrence = 9

Time Complexity: O(log n) 
Auxiliary Space: O(1) 

An approach using inbuilt functions:

Below is the implementation using an inbuilt function:

C++

#include <bits/stdc++.h>
using namespace std;

void findFirstAndLast(int arr[], int n, int x)
{
    int first, last;
    // to store first occurrence
    first = lower_bound(arr, arr + n, x) - arr;
    // to store last occurrence
    last = upper_bound(arr, arr + n, x) - arr - 1;

    if (first == n) {
        first = -1;
        last = -1;
    }
    cout << "First Occurrence = " << first
         << "\nLast Occurrence = " << last;
}

// Driver code
int main()
{
    int arr[] = { 1, 2, 2, 2, 2, 3, 4, 7, 8, 8 };
    int n = sizeof(arr) / sizeof(int);
    int x = 8;
    findFirstAndLast(arr, n, x);
    return 0;
}

Java

// Java program for the above approach
import java.util.ArrayList;
public class GFG {
    public static int first(ArrayList list, int x)
    {
        // return first occurrence index
        // of element x in ArrayList
        // using method indexOf()
        return list.indexOf(x);
    }
    public static int last(ArrayList list, int x)
    {
        // return last occurrence index
        // of element x in ArrayList
        // using method lastIndexOf()
        return list.lastIndexOf(x);
    }
    public static void main(String[] args)
    {
        int arr[] = { 1, 2, 2, 2, 2, 3, 4, 7, 8, 8 };
        ArrayList<Integer> clist = new ArrayList<>();

        // adding elements of array to ArrayList
        for (int i : arr)
            clist.add(i);
        int x = 8;

        // displaying the first occurrence
        System.out.println("First Occurrence = "
                           + first(clist, x));

        // displaying the last occurrence
        System.out.println("Last Occurrence = "
                           + last(clist, x));
    }
}

Python

# Python3 program to find first and
# last occurrences of a number in a
# given sorted array

# function to find the first occurrence of the number
def first(arr, low, high, key, length):
  return arr.index(x)

# function to find the last occurrence of the number
def last(arr, low, high, key, length):
  return length - 1 - arr[::-1].index(x)

# Driver program
arr = [1, 2, 2, 2, 2, 3, 4, 7, 8, 8]
n = len(arr)

x = 8
print('First Occurrence = ',
      first(arr, 0, n - 1, x, n))
print('Last Occurrence = ',
      last(arr, 0, n - 1, x, n))

# This code is contributed by postaarpan

C#

// Include namespace system
using System;
using System.Collections.Generic;

class GFG
{
    public static int first(List<int> list, int x)
    {

        // return first occurrence index
        // of element x in ArrayList
        // using method indexOf()
        return list.IndexOf(x);
    }
    public static int last(List<int> list, int x)
    {

        // return last occurrence index
        // of element x in ArrayList
        // using method lastIndexOf()
        return list.LastIndexOf(x);
    }
    public static void Main()
    {
        int[] arr = {1, 2, 2, 2, 2, 3, 4, 7, 8, 8};
        var clist = new List<int>();

        // adding elements of array to ArrayList
        foreach (int i in arr)
        {            clist.Add(i);
        }
        var x = 8;

        // displaying the first occurrence
        Console.WriteLine("First Occurrence = " + GFG.first(clist, x).ToString());

        // displaying the last occurrence
        Console.WriteLine("Last Occurrence = " + GFG.last(clist, x).ToString());
    }
}

// This code is contributed by aadityaburujwale.

Javascript

// JavaScript program for the above approach

function first(list, x){
    // return first occurrence index
    // of element x in ArrayList
    // using method indexOf()
    return list.indexOf(x);
}

function last(list, x){
    // return last occurrence index
    // of element x in ArrayList
    // using method lastIndexOf()
    return list.lastIndexOf(x);
}

let arr = [ 1, 2, 2, 2, 2, 3, 4, 7, 8, 8 ];
let clist = new Array();

// adding elements of array to ArrayList
for(let i=0;i<arr.length;i++){
    clist.push(arr[i]);
}
let x = 8;

// displaying the first occurrence
console.log("First Occurrence = " + first(clist, x) + "<br>");

// displaying the last occurrence
console.log("Last Occurrence = " + last(clist, x));

// This code is contributed by lokeshmvs21.

Output

First Occurrence = 8
Last Occurrence = 9

Time Complexity: O(n) As Inbuilt function runs a internal for loop for finding the first index and last index of that element so it takes O(n)
Auxiliary Space: O(1) 

Another Approach:

• For the first occurrence, we will first find the index of the number and then search again in the left subarray as long as we are finding the number.
• For the last occurrence, we will first find the index of the number and then search again in the right subarray as long as we are finding the number

Follow the steps mentioned below to implement the idea: 

• First we create an array ans[] of size 2 to store the first occurrence and last occurrence.Create 
• Create a function search(int[] nums, int target, boolean findStartIndex) to find the index value of target.
• And for first occurrence set ans[0] = search(arr, target, true) and last occurrence set ans[1] = search(arr, target, false) and these function do following things:

                ∗ Set ans = -1 , start = 0 , end = arr.length – 1 .

                ∗ Iterate a loop while start <= end , such as:

                               ∗ Set mid = start + (end – start) / 2 .

                               ∗ Check if target < arr[mid] ,then set end = mid – 1.

                               ∗  Else check if target > arr[mid], then set start = mid – 1.

                               ∗ Otherwise , set ans = mid and check further such as 

                                          ∗ If findStartIndex == true , then set end = mid – 1 .

                                          ∗ Else set start = mid + 1.

               ∗ Return ans as the index value of target.            

Below is the implementation of the above approach:

C++

#include <iostream>
using namespace std;

// if target is present in arr[] then returns
// the index of FIRST occurrence and last occurrence
// of target in arr[0..n-1], otherwise returns -1
int search(int nums[], int n, int target, bool findStartIndex) {
    int ans = -1;
    int start = 0;
    int end = n - 1;
    while (start <= end) {

        // find the middle element
        // might be possible that (start + end)
      // exceeds the range of int in C++
        int mid = start + (end - start) / 2;

        if (target < nums[mid]) {
            end = mid - 1;
        } else if (target > nums[mid]) {
            start = mid + 1;
        } else {
            // potential ans found
            ans = mid;
            if (findStartIndex) {
                end = mid - 1;
            } else {
                start = mid + 1;
            }
        }
    }

    return ans;
}

// Driver program
int main() {
    int arr[] = {1, 2, 2, 2, 2, 3, 4, 7, 8, 8};
    int n = sizeof(arr) / sizeof(arr[0]);
    int x = 8;
    int ans[] = {-1,-1};

    // For first occurrence
    ans[0] = search(arr,n,x,true);

    if(ans[0] != -1){
        // For last occurrence
        ans[1] = search(arr,n,x,false);
    }

    cout << "First Occurrence: " << ans[0] << endl;
    cout << "Last Occurrence: " << ans[1] << endl;
    return 0;
}

Java

// Java program to find first
// and last occurrences of a
// number in a given sorted array
import java.util.*;
class GFG {

    // if target is present in arr[] then
    // returns the index of FIRST
    // occurrence and last occurrence of target in
    // arr[0..n-1], otherwise returns -1
    static int search(int[] nums, int target,
                      boolean findStartIndex)
    {
        int ans = -1;
        int start = 0;
        int end = nums.length - 1;
        while (start <= end) {
            // find the middle element
            // int mid = (start + end) / 2;
            //  might be possible that (start + end)
            //  exceeds the range of int in  java
            int mid = start + (end - start) / 2;

            if (target < nums[mid]) {
                end = mid - 1;
            }
            else if (target > nums[mid]) {
                start = mid + 1;
            }
            else {
                // potential ans found
                ans = mid;
                if (findStartIndex) {
                    end = mid - 1;
                }
                else {
                    start = mid + 1;
                }
            }
        }

        return ans;
    }

    // Driver program
    public static void main(String[] args)
    {
        int arr[] = { 1, 2, 2, 2, 2, 3, 4, 7, 8, 8 };
        int n = arr.length;
        int x = 8;
        int[] ans = { -1, -1 };
        // For first occurrence
        ans[0] = search(arr,x, true);
        if (ans[0] != -1) {
            // For last occurrence
            ans[1] = search(arr, x, false);
        }
        System.out.println("First Occurrence = " + ans[0]);
        System.out.println("Last Occurrence = " + ans[1]);
    }
}

C#

using System;

public class GFG {
    // if target is present in nums[] then
    // returns the index of FIRST
    // occurrence and last occurrence of target in
    // nums[0..n-1], otherwise returns -1
    static int search(int[] nums, int target,
                      bool findStartIndex)
    {
        int ans = -1;
        int start = 0;
        int end = nums.Length - 1;
        while (start <= end) {
            // find the middle element
            // int mid = (start + end) / 2;
            //  might be possible that (start + end)
            //  exceeds the range of int in  C#
            int mid = start + (end - start) / 2;

            if (target < nums[mid]) {
                end = mid - 1;
            }
            else if (target > nums[mid]) {
                start = mid + 1;
            }
            else {
                // potential ans found
                ans = mid;
                if (findStartIndex) {
                    end = mid - 1;
                }
                else {
                    start = mid + 1;
                }
            }
        }

        return ans;
    }

    // Driver program
    public static void Main(string[] args)
    {
        int[] nums = { 1, 2, 2, 2, 2, 3, 4, 7, 8, 8 };
        int n = nums.Length;
        int target = 8;
        int[] ans = { -1, -1 };
        // For first occurrence
        ans[0] = search(nums,target, true);
        if (ans[0] != -1) {
            // For last occurrence
            ans[1] = search(nums, target, false);
        }
        Console.WriteLine("First Occurrence = " + ans[0]);
        Console.WriteLine("Last Occurrence = " + ans[1]);
    }
}

Python3

# Python program to find first
# and last occurrences of a
# number in a given sorted array

# if target is present in nums[] then
# returns the index of FIRST
# occurrence and last occurrence of target in
# nums[0..n-1], otherwise returns -1


def search(nums, target, findStartIndex):
    ans = -1
    start = 0
    end = len(nums) - 1
    while start <= end:
        # find the middle element

        mid = start + (end - start) // 2

        if target < nums[mid]:
            end = mid - 1
        elif target > nums[mid]:
            start = mid + 1
        else:
            # potential ans found
            ans = mid
            if findStartIndex:
                end = mid - 1
            else:
                start = mid + 1

    return ans


# Driver program
arr = [1, 2, 2, 2, 2, 3, 4, 7, 8, 8]
n = len(arr)
x = 8
ans = [-1, -1]

# For first occurrence
ans[0] = search(arr, x, True)
if ans[0] != -1:
    # For last occurrence
    ans[1] = search(arr, x, False)

print("First Occurrence =", ans[0])
print("Last Occurrence =", ans[1])

Javascript

// JavaScript program to find first
// and last occurrences of a
// number in a given sorted array

// if target is present in nums[] then
// returns the index of FIRST
// occurrence and last occurrence of target in
// nums[0..n-1], otherwise returns -1

function search(nums, target, findStartIndex) {
  let ans = -1;
  let start = 0;
  let end = nums.length - 1;
  while (start <= end) {
    // find the middle element
    let mid = Math.floor(start + (end - start) / 2);
    if (target < nums[mid]) {
      end = mid - 1;
    } else if (target > nums[mid]) {
      start = mid + 1;
    } else {
      // potential ans found
      ans = mid;
      if (findStartIndex) {
        end = mid - 1;
      } else {
        start = mid + 1;
      }
    }
  }
  return ans;
}

// Driver program
let arr = [1, 2, 2, 2, 2, 3, 4, 7, 8, 8];
let n = arr.length;
let x = 8;
let ans = [-1, -1];

// For first occurrence
ans[0] = search(arr, x, true);
if (ans[0] != -1) {
  // For last occurrence
  ans[1] = search(arr, x, false);
}

console.log("First Occurrence =", ans[0]);
console.log("Last Occurrence =", ans[1]);

Output

First Occurrence: 8
Last Occurrence: 9

Time Complexity: O(log n)
Auxiliary Space: O(1) 

Extended Problem : Count number of occurrences in a sorted array

This article is contributed by DANISH_RAZA. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.