Dado un arreglo de números enteros nums de tamaño n, se debe ancontrar un elemento pico y retornar su índice. Un elemento pico es aquel cuyo valor es estrictamente mayor que el de sus vecinos adyacentes. Si existen múltiples picos, basta con retornar el índice de cualquiera de ellos.

Consideraciones importantes:

• Se asume que nums[-1] = nums[n] = -∞, es decir, los bordes del arreglo son considerados como menos infinito.
• Para todo índice i válido, nums[i] != nums[i + 1].
• El problema puede resolverse con una complejidad temporal de O(log n).

Enfoque 1: Búsqueda binaria

Gracias a la condición de que los bordes valen -∞, se garantiza la existencia de al menos un pico en el arreglo. La clave del enfoque radica en comparar el elemento central con su vecino derecho para decidir hacia qué mitad continuar la búsqueda:

• Si nums[center] > nums[center + 1], el pico se encuentra en la mitad izquierda (incluyendo center), por lo que se ajusta el límite derecho: right = center.
• Si nums[center] < nums[center + 1], el pico está en la mitad derecha, por lo que se ajusta el límite izquierdo: left = center + 1.

Dado que nunca se asigna right = center - 1, no es necesario preocuparse por la división con truncamiento hacia abajo. La búsqueda converge cuando left y right coinciden.

Análisis de complejidad:

• Temporal: O(log n)
• Espacial: O(1)

class Solution {
    public int findPeakElement(int[] nums) {
        int left = 0;
        int right = nums.length - 1;
        
        while (left < right) {
            int center = left + (right - left) / 2;
            
            if (nums[center] > nums[center + 1]) {
                right = center;
            } else {
                left = center + 1;
            }
        }
        
        return left;
    }
}

Enfoque 2: Localización del valor máximo

Una alternativa más directa consiste en encontrar el índice del valor máximo dentro del arreglo. Dado que el elemento más grande siempre será mayor que sus vecinos, este necesariamente es un pico válido. Se realiza un recorrido lineal comparando cada elemanto con el máximo actual.

Análisis de complejidad:

• Temporal: O(n)
• Espacial: O(1)

class Solution {
    public int findPeakElement(int[] nums) {
        int maxIdx = 0;
        
        for (int i = 1; i < nums.length; i++) {
            if (nums[i] > nums[maxIdx]) {
                maxIdx = i;
            }
        }
        
        return maxIdx;
    }
}