Un elemento en una array ordenada se puede encontrar en el tiempo O (log n) a través de una búsqueda binaria . Pero supongamos que rotamos una array ordenada de orden ascendente en algún pivote desconocido para usted de antemano. Entonces, por ejemplo, 1 2 3 4 5 podría convertirse en 3 4 5 1 2. Inventa una forma de encontrar un elemento en el arreglo rotado en tiempo O(log n).
Ejemplo:
Input : arr[] = {5, 6, 7, 8, 9, 10, 1, 2, 3};
key = 3
Output : Found at index 8
Input : arr[] = {5, 6, 7, 8, 9, 10, 1, 2, 3};
key = 30
Output : Not found
Input : arr[] = {30, 40, 50, 10, 20}
key = 10
Output : Found at index 3
Todas las soluciones proporcionadas aquí asumen que todos los elementos de la array son distintos.
Solución básica:
Enfoque:
- La idea es encontrar el punto de pivote, dividir la array en dos sub-arrays y realizar una búsqueda binaria.
- La idea principal para encontrar el pivote es: para una array ordenada (en orden creciente) y pivotada, el elemento pivote es el único elemento para el que el siguiente elemento es más pequeño que él.
- Usando la declaración anterior y el pivote de búsqueda binaria se puede encontrar.
- Después de encontrar el pivote, divida la array en dos sub-arrays.
- Ahora los subconjuntos individuales se ordenan para que el elemento se pueda buscar mediante la búsqueda binaria.
Implementación:
Input arr[] = {3, 4, 5, 1, 2}
Element to Search = 1
1) Find out pivot point and divide the array in two
sub-arrays. (pivot = 2) /*Index of 5*/
2) Now call binary search for one of the two sub-arrays.
(a) If element is greater than 0th element then
search in left array
(b) Else Search in right array
(1 will go in else as 1 < 0th element(3))
3) If element is found in selected sub-array then return index
Else return -1.
A continuación se muestra la implementación del enfoque anterior:
Python3
# Python Program to search an element
# in a sorted and pivoted array
# Searches an element key in a pivoted
# sorted array arrp[] of size n
def pivotedBinarySearch(arr, n, key):
pivot = findPivot(arr, 0, n-1);
# If we didn't find a pivot,
# then array is not rotated at all
if pivot == -1:
return binarySearch(arr, 0, n-1, key);
# If we found a pivot, then first
# compare with pivot and then
# search in two subarrays around pivot
if arr[pivot] == key:
return pivot
if arr[0] <= key:
return binarySearch(arr, 0, pivot-1, key);
return binarySearch(arr, pivot + 1, n-1, key);
# Function to get pivot. For array
# 3, 4, 5, 6, 1, 2 it returns 3
# (index of 6)
def findPivot(arr, low, high):
# base cases
if high < low:
return -1
if high == low:
return low
# low + (high - low)/2;
mid = int((low + high)/2)
if mid < high and arr[mid] > arr[mid + 1]:
return mid
if mid > low and arr[mid] < arr[mid - 1]:
return (mid-1)
if arr[low] >= arr[mid]:
return findPivot(arr, low, mid-1)
return findPivot(arr, mid + 1, high)
# Standard Binary Search function*/
def binarySearch(arr, low, high, key):
if high < low:
return -1
# low + (high - low)/2;
mid = int((low + high)/2)
if key == arr[mid]:
return mid
if key > arr[mid]:
return binarySearch(arr, (mid + 1), high,
key);
return binarySearch(arr, low, (mid -1), key);
# Driver program to check above functions */
# Let us search 3 in below array
arr1 = [5, 6, 7, 8, 9, 10, 1, 2, 3]
n = len(arr1)
key = 3
print("Index of the element is : ",
pivotedBinarySearch(arr1, n, key))
# This is contributed by Smitha Dinesh Semwal
Producción:
Index of the element is : 8
Análisis de Complejidad:
- Complejidad temporal: O(log n).
La búsqueda binaria requiere comparaciones log n para encontrar el elemento. Entonces la complejidad del tiempo es O (log n). - Complejidad espacial: O(1), No se requiere espacio adicional.
Gracias a Ajay Mishra por la solución inicial.
Solución mejorada:
Enfoque: en lugar de dos o más pasadas de búsqueda binaria, el resultado se puede encontrar en una pasada de búsqueda binaria. La búsqueda binaria debe modificarse para realizar la búsqueda. La idea es crear una función recursiva que tome l y r como rango en la entrada y la clave.
1) Find middle point mid = (l + h)/2
2) If key is present at middle point, return mid.
3) Else If arr[l..mid] is sorted
a) If key to be searched lies in range from arr[l]
to arr[mid], recur for arr[l..mid].
b) Else recur for arr[mid+1..h]
4) Else (arr[mid+1..h] must be sorted)
a) If key to be searched lies in range from arr[mid+1]
to arr[h], recur for arr[mid+1..h].
b) Else recur for arr[l..mid]
A continuación se muestra la implementación de la idea anterior:
Python3
# Search an element in sorted and rotated array using
# single pass of Binary Search
# Returns index of key in arr[l..h] if key is present,
# otherwise returns -1
def search (arr, l, h, key):
if l > h:
return -1
mid = (l + h) // 2
if arr[mid] == key:
return mid
# If arr[l...mid] is sorted
if arr[l] <= arr[mid]:
# As this subarray is sorted, we can quickly
# check if key lies in half or other half
if key >= arr[l] and key <= arr[mid]:
return search(arr, l, mid-1, key)
return search(arr, mid + 1, h, key)
# If arr[l..mid] is not sorted, then arr[mid... r]
# must be sorted
if key >= arr[mid] and key <= arr[h]:
return search(a, mid + 1, h, key)
return search(arr, l, mid-1, key)
# Driver program
arr = [4, 5, 6, 7, 8, 9, 1, 2, 3]
key = 6
i = search(arr, 0, len(arr)-1, key)
if i != -1:
print ("Index: % d"% i)
else:
print ("Key not found")
# This code is contributed by Shreyanshi Arun
Producción:
Index: 2
Análisis de Complejidad:
- Complejidad temporal: O(log n).
La búsqueda binaria requiere comparaciones log n para encontrar el elemento. Entonces la complejidad del tiempo es O (log n). - Complejidad espacial: O(1).
Como no se requiere espacio adicional.
Gracias a Gaurav Ahirwar por sugerir la solución anterior.
¿Cómo manejar los duplicados?
No parece posible buscar en el tiempo O (Inicio de sesión) en todos los casos cuando se permiten duplicados. Por ejemplo, considere buscar 0 en {2, 2, 2, 2, 2, 2, 2, 2, 0, 2} y {2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2 , 2}.
No parece posible decidir si repetir la mitad izquierda o la mitad derecha haciendo un número constante de comparaciones en el medio.
Artículos similares:
- Encuentre el elemento mínimo en una array ordenada y rotada
- Dada una array ordenada y rotada, encuentre si hay un par con una suma dada.
Escriba comentarios si encuentra algún error en los códigos/algoritmos anteriores, o encuentre otras formas de resolver el mismo problema.
Consulte el artículo completo sobre Buscar un elemento en una array ordenada y rotada para obtener más detalles.
Publicación traducida automáticamente
Artículo escrito por GeeksforGeeks-1 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA