Skip to content
Related Articles

Related Articles

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

View Discussion
Improve Article
Save Article
Like Article
  • Difficulty Level : Easy
  • Last Updated : 24 Jun, 2022

Given a sorted array with possibly duplicate elements, the task is to find indexes of 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

The Naive Approach is to run a for loop and check given elements in an array.  

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

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 solution to this problem is to use a 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;
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
        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
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
        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
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) 
Iterative Implementation of Binary Search Solution : 
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
        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 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
        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
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) 
Using ArrayList
Add all the elements of the array to ArrayList and using indexOf() and lastIndexOf() method we will find the first position and the last position of the element in the array.
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));
    }
}
Output
First Occurrence = 8
Last Occurrence = 9
Output:
First Occurrence = 8
Last Occurrence = 9
 Another approach using c++ STL functions lower and upper bound
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;
}
Output
First Occurrence = 8
Last Occurrence = 9
Time Complexity : O(log n)
 Auxiliary Space : O(1) 
Another approach is using Python3 “index( )” function, which searches for a given element in the given List and returns the index of its first occurrence in the list. Using “index( )” function, we find the First Occurrence, and by Using “index( )” function on the reversed List, we find the Last Occurrence.
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 & LAST
# occurrence of x in arr[0..n-1],
# otherwise returns -1
def first_last(arr, x):
  first = arr.index(x)
  last = len(arr) - 1 - arr[::-1].index(x)
  print("First Occurrence =", first)
  print("Last Occurrence =", last)
   
 
# Driver code
arr = [ 1, 2, 2, 2, 2, 3, 4, 7, 8, 8 ]
x = 8
first_last(arr, x);
  
# This code is contributed by kothavvsaakash
Output
First Occurrence = 8
Last Occurrence = 9
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.
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

My Personal Notes
arrow_drop_up
Next

Count number of occurrences (or frequency) in a sorted array
Recommended Articles
Page :
Remaining array element after repeated removal of last element and subtraction of each element from next adjacent element
23, Feb 21
Last element of an array after repeatedly removing the first element and appending it to the end of the array twice exactly K times
27, Jun 21
Count distinct sequences obtained by replacing all elements of subarrays having equal first and last elements with the first element any number of times
29, Jun 21
Sort an array having first N elements sorted and last M elements are unsorted
15, Jun 21
Arrange array elements such that last digit of an element is equal to first digit of the next element
29, Apr 19
Last seen array element (last appearance is earliest)
19, Nov 17
Check if the array can be sorted only if the elements on given positions can be swapped
07, May 20
Longest Subarray with first element greater than or equal to Last element
18, Aug 18
Check if sum of array can be made equal to X by removing either the first or last digits of every array element
23, Mar 21
Javascript Program for Last duplicate element in a sorted array
01, Dec 21
C++ Program for Last duplicate element in a sorted array
01, Dec 21
Java Program for Last duplicate element in a sorted array
01, Dec 21
Python Program for Last duplicate element in a sorted array
01, Dec 21
Php Program for Last duplicate element in a sorted array
01, Dec 21
Last duplicate element in a sorted array
01, Feb 18
Find the most frequent element K positions apart from X in given Array
11, Mar 22
Minimise sum of products of positions of each element with element at (i+K)%N
09, Mar 22
Maximize first element of Array by deleting first or adding a previously deleted element
29, Mar 22
Maximum difference between first and last indexes of an element in array
24, May 17
Split array into minimum number of subarrays having GCD of its first and last element exceeding 1
01, Sep 20
Check if concatenation of first and last digits forms a prime number or not for each array element
02, Mar 21
Maximize score by rearranging Array such that absolute difference of first and last element is minimum
16, Nov 21
Find last element after deleting every second element in array of n integers
30, Dec 17
Find the last positive element remaining after repeated subtractions of smallest positive element from all Array elements
10, Sep 21
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
GeeksforGeeks
Vote for difficulty
Current difficulty :
Easy





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!