leetcode1287 (simple) - más de 25% del número de elementos aparecen en una matriz ordenada

Título: Dada una lista ordenada, devuelve el número de ocurrencias de más del 25% de sus elementos, para asegurar que hay uno y sólo un sujeto.

Entrada: arr = [ 1 , 2 , 2 , 6 , 6 , 6 , 6 , 7 , 10 ] 
de salida: 6

análisis:

Método uno: Traverse

La complejidad de tiempo es O (n), la complejidad espacial es O (1)

    int findSpecialInteger (vector < int > & arr) {
         int len = arr.size ();
        int paso = len / 4 ;
        para ( int i = 0 ; i + paso <len; i ++ ) 
        { 
            si (arr [i] == arr [i + paso]) 
                 de retorno arr [i]; 
        } 
        Retorno - 1 ; 
    }

Segundo método: búsqueda binaria

El objeto de la solicitud, el número entero x satisface la condición de al menos lapso aparecido = arr.Length / 4 + 1 array arr vistas, a continuación, se puede concluir que: el elemento de matriz de arr arr [0], Arr [lapso], arr [lapso * 2], ... debe contener x.

Dado que el número de la extensión continua, el ajuste de sensibilidad debe ser un múltiplo de.

Así que tomamos el lapso de unos pocos intervalos de LOWER_BOUND y el aspecto de límite superior, obtener el número de ocurrencias.

    int findSpecialInteger (vector < int > & arr) {
         int n = arr.size ();
        int paso = n / 4 + 1 ;
        para ( int i = 0 ; i <n; i + = paso) 
        { 
            vector < int > :: iterador it_l = LOWER_BOUND (arr.begin (), arr.end (), arr [i]); 
            vector < int > :: iterador it_r = upper_bound (arr.begin (), arr.end (), arr [i]);
            si - (it_r it_l> = paso)
                 de retornoarr [i]; 
        } 
        Retorno - 1 ; 
    }

A primera vista la complejidad del tiempo es O (nlogn) ??

A primera vista, los elementos enumerados hasta 4, la complejidad del tiempo es O (log n).

Enlaces de referencia: https://leetcode-cn.com/problems/element-appearing-more-than-25-in-sorted-array/solution/you-xu-shu-zu-zhong-chu-xian-ci-shu -chao-guo-25d-3 /