¿Cuál es la manera eficiente de encontrar todos los números en orden en una matriz en el tiempo O (N)?

Puede resolver esto en tiempo O (N) usando un espacio constante.

Itere sobre la matriz de principio a fin, rastreando el elemento de matriz más grande y el rango de coincidencia actual (si corresponde).

Si no tiene coincidencia y la entrada actual es más grande que cualquier otra vista, ese es el comienzo y el final de su rango.

Si tienes una coincidencia, sigue inmediatamente su final, y estás aumentando monotónicamente, ese es el nuevo final.

De lo contrario, siempre que seas más pequeño que el elemento final del rango, acortarás una entrada y restablecerás la coincidencia si te quedas sin entradas.

Aunque hay dos bucles anidados, mi solución es O (N) porque visita cada entrada como máximo dos veces: una vez hacia adelante y posiblemente una hacia atrás al acortar una secuencia coincidente al encontrar un número siguiente más pequeño que él.

  #include 
 #include 

 const int *
 get_ordered (const int * data, size_t count, size_t * count_out)
 {
     const int * begin, * end, * más grande, * i, * data_end;
     para (comienzo = fin = más grande = NULO, i = datos, fin_datos = datos + recuento;
          i  * más grande) {
             mayor = i;
         }

         if (! begin && * i> = * Mayor) {
             comenzar = i;
             final = i + 1;
         }

         if (end == i && * i> end [-1]) {
             ++ fin;
         } más {
             while (end && * i 
  que se puede validar con 
  #include 
 #include 

 hoyo estatico
 check_ordered (const char * name, const int * data, size_t count) {
     const int * data_end, * begin, * end, * i;
     size_t count_out;

     data_end = data + count;
     begin = get_ordered (data, count, & count_out);
     end = begin + count_out;

     afirmar (fin> = datos);
     afirmar (fin <= final_de_datos);

     afirmar (comenzar> = datos);
     afirmar (comenzar <= fin);

     printf ("% s in", nombre);
     for (i = data; i  i [-1]);
     }

     para (; i  fin [-1]);
     }

     printf ("\ n");
 }

  productor 
  vaciar adentro
 solo entrada 1 salida 1
 todo dentro 1 2 3 fuera 1 2 3
 ninguno en 3 2 1 fuera
 uno en 1 3 2 4 fuera 1
 dos en 1 2 4 3 5 fuera 1 2
 saltar 2 1 3 4 5 7 6 salir 3 4 5
 saltar2 en 2 1 4 6 3 5 7 fuera 7