Search an element in a sorted and rotated array with duplicates
Last Updated :
27 Feb, 2023
Given an array arr[] which is sorted and rotated, the task is to find an element in the rotated array (with duplicates) in O(log n) time.
Note: Print the index where the key exists. In case of multiple answer print any of them
Examples:
Input: arr[] = {3, 3, 3, 1, 2, 3}, key = 3
Output: 0
arr[0] = 3
Input: arr[] = {3, 3, 3, 1, 2, 3}, key = 11
Output: -1
11 is not present in the given array.
Approach: The idea is the same as the previous one without duplicates. The only difference is that due to the existence of duplicates, arr[low] == arr[mid] could be possible, the first half could be out of order (i.e. not in the ascending order, e.g. {3, 1, 2, 3, 3, 3, 3}) and we have to deal this case separately.
In that case, it is guaranteed that arr[high] also equal to arr[mid], so the condition arr[mid] == arr[low] == arr[high] can be checked before the original logic, and if so then move left and right both towards the middle by 1 and repeat.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
int search( int arr[], int l, int h, int key)
{
if (l > h)
return -1;
int mid = l + (h - l) / 2;
if (arr[mid] == key)
return mid;
if ((arr[l] == arr[mid])
&& (arr[h] == arr[mid]))
{
++l;
--h;
return search(arr, l, h, key);
}
if (arr[l] <= arr[mid]) {
if (key >= arr[l] && key <= arr[mid])
return search(arr, l, mid - 1, key);
return search(arr, mid + 1, h, key);
}
if (key >= arr[mid] && key <= arr[h])
return search(arr, mid + 1, h, key);
return search(arr, l, mid - 1, key);
}
int main()
{
int arr[] = { 3, 3, 1, 2, 3, 3 };
int n = sizeof (arr) / sizeof ( int );
int key = 3;
cout << search(arr, 0, n - 1, key);
return 0;
}
|
Java
class GFG
{
static int search( int arr[], int l, int h, int key)
{
if (l > h)
return - 1 ;
int mid = l + (h - l) / 2 ;
if (arr[mid] == key)
return mid;
if ((arr[l] == arr[mid])
&& (arr[h] == arr[mid]))
{
l++;
h--;
return search(arr,l,h,key);
}
else if (arr[l] <= arr[mid])
{
if (key >= arr[l] && key <= arr[mid])
return search(arr, l, mid - 1 , key);
else
return search(arr, mid + 1 , h, key);
}
else if (key >= arr[mid] && key <= arr[h])
return search(arr, mid + 1 , h, key);
return search(arr, l, mid - 1 , key);
}
public static void main (String[] args)
{
int arr[] ={ 3 , 3 , 1 , 2 , 3 , 3 };
int n = arr.length;
int key = 3 ;
System.out.println(search(arr, 0 , n - 1 , key));
}
}
|
Python3
def search(arr, l, h, key) :
if (l > h) :
return - 1 ;
mid = (l + h) / / 2 ;
if (arr[mid] = = key) :
return mid;
if ((arr[l] = = arr[mid]) and (arr[h] = = arr[mid])) :
l + = 1 ;
h - = 1 ;
return search(arr, l, h, key)
if (arr[l] < = arr[mid]) :
if (key > = arr[l] and key < = arr[mid]) :
return search(arr, l, mid - 1 , key);
return search(arr, mid + 1 , h, key);
if (key > = arr[mid] and key < = arr[h]) :
return search(arr, mid + 1 , h, key);
return search(arr, l, mid - 1 , key);
if __name__ = = "__main__" :
arr = [ 3 , 3 , 1 , 2 , 3 , 3 ];
n = len (arr);
key = 3 ;
print (search(arr, 0 , n - 1 , key));
|
C#
using System;
class GFG
{
static int search( int []arr, int l, int h, int key)
{
if (l > h)
return -1;
int mid = l + (h - l) / 2;
if (arr[mid] == key)
return mid;
if ((arr[l] == arr[mid])
&& (arr[h] == arr[mid]))
{
++l;
--h;
return search(arr, l, h, key)
}
if (arr[l] <= arr[mid])
{
if (key >= arr[l] && key <= arr[mid])
return search(arr, l, mid - 1, key);
return search(arr, mid + 1, h, key);
}
if (key >= arr[mid] && key <= arr[h])
return search(arr, mid + 1, h, key);
return search(arr, l, mid - 1, key);
}
public static void Main ()
{
int []arr = { 3, 3, 1, 2, 3, 3 };
int n = arr.Length;
int key = 3;
Console.WriteLine(search(arr, 0, n - 1, key));
}
}
|
Javascript
<script>
function search(arr, l, h, key)
{
if (l > h)
return -1;
let mid = parseInt((l + h) / 2, 10);
if (arr[mid] == key)
return mid;
if ((arr[l] == arr[mid])
&& (arr[h] == arr[mid]))
{
++l;
--h;
return search(arr, l, h, key)
}
if (arr[l] <= arr[mid])
{
if (key >= arr[l] && key <= arr[mid])
return search(arr, l, mid - 1, key);
return search(arr, mid + 1, h, key);
}
if (key >= arr[mid] && key <= arr[h])
return search(arr, mid + 1, h, key);
return search(arr, l, mid - 1, key);
}
let arr = [ 3, 3, 1, 2, 3, 3 ];
let n = arr.length;
let key = 3;
document.write(search(arr, 0, n - 1, key));
</script>
|
Time Complexity: O(log N), where n represents the size of the given array. If all the elements are same, we may end up doing a linear search.
Auxiliary Space: O(logN) due to recursive stack space.
This approach is better than the recursive one as no auxiliary space is required in this case
C++
#include <bits/stdc++.h>
using namespace std;
int search( int arr[], int low, int high, int key)
{
while (low <= high) {
int mid = low + (high - low) / 2;
if (arr[mid] == key) {
return mid;
}
if (arr[mid] == arr[low] && arr[mid] == arr[high]) {
++low;
--high;
continue ;
}
if (arr[low] <= arr[mid]) {
if (key >= arr[low] && key < arr[mid])
high = mid - 1;
else
low = mid + 1;
}
else {
if (key <= arr[high] && key > arr[mid])
low = mid + 1;
else
high = mid - 1;
}
}
return -1;
}
int main()
{
int arr[] = { 3, 3, 1, 2, 3, 3 };
int n = sizeof (arr) / sizeof (arr[0]);
int key = 3;
cout << search(arr, 0, n - 1, key) << endl;
return 0;
}
|
Java
import java.util.Scanner;
public class Main {
public static int search( int [] arr, int low, int high, int key) {
while (low <= high) {
int mid = low + (high - low) / 2 ;
if (arr[mid] == key) {
return mid;
}
if (arr[mid] == arr[low] && arr[mid] == arr[high]) {
++low;
--high;
continue ;
}
if (arr[low] <= arr[mid]) {
if (key >= arr[low] && key < arr[mid])
high = mid - 1 ;
else
low = mid + 1 ;
}
else {
if (key <= arr[high] && key > arr[mid])
low = mid + 1 ;
else
high = mid - 1 ;
}
}
return - 1 ;
}
public static void main(String[] args) {
int [] arr = { 3 , 3 , 1 , 2 , 3 , 3 };
int n = arr.length;
int key = 3 ;
System.out.println(search(arr, 0 , n - 1 , key));
}
}
|
Python3
def search(arr, low, high, key):
while low < = high:
mid = low + (high - low) / / 2
if arr[mid] = = key:
return mid
if arr[mid] = = arr[low] and arr[mid] = = arr[high]:
low + = 1
high - = 1
continue
if arr[low] < = arr[mid]:
if key > = arr[low] and key < arr[mid]:
high = mid - 1
else :
low = mid + 1
else :
if key < = arr[high] and key > arr[mid]:
low = mid + 1
else :
high = mid - 1
return - 1
arr = [ 3 , 3 , 1 , 2 , 3 , 3 ]
n = len (arr)
key = 3
print (search(arr, 0 , n - 1 , key))
|
C#
using System;
class MainClass {
public static int Search( int [] arr, int low, int high, int key) {
while (low <= high) {
int mid = low + (high - low) / 2;
if (arr[mid] == key) {
return mid;
}
if (arr[mid] == arr[low] && arr[mid] == arr[high]) {
++low;
--high;
continue ;
}
if (arr[low] <= arr[mid]) {
if (key >= arr[low] && key < arr[mid])
high = mid - 1;
else
low = mid + 1;
}
else {
if (key <= arr[high] && key > arr[mid])
low = mid + 1;
else
high = mid - 1;
}
}
return -1;
}
public static void Main() {
int [] arr = { 3, 3, 1, 2, 3, 3 };
int n = arr.Length;
int key = 3;
Console.WriteLine(Search(arr, 0, n - 1, key));
}
}
|
Javascript
function search(arr, low, high, key) {
while (low <= high) {
let mid = Math.floor(low + (high - low) / 2);
if (arr[mid] === key) {
return mid;
}
if (arr[mid] === arr[low] && arr[mid] === arr[high]) {
low++;
high--;
continue ;
}
if (arr[low] <= arr[mid]) {
if (key >= arr[low] && key < arr[mid]) {
high = mid - 1;
} else {
low = mid + 1;
}
} else {
if (key <= arr[high] && key > arr[mid]) {
low = mid + 1;
} else {
high = mid - 1;
}
}
}
return -1;
}
let arr = [3, 3, 1, 2, 3, 3];
let n = arr.length;
let key = 3;
console.log(search(arr, 0, n - 1, key));
|
Time Complexity: O(N), where n represents the size of the given array. If all the elements are same, we may end up doing a linear search.
Auxiliary Space: O(1)
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...