Algoritmo de Busqueda

[rodno]

hola todos los foreros,

estoy realizando una aplicacion web que se conecta a 2 diferentes Bases de datos,
funciona como si fuera un importador, es decir, de la BD origen realiza una consulta y tiene que ir comparando si existe en la BD destino, si existe lo actualiza y si no lo inserta, se trabaja con mas de 2000 registros,
he probado hacerlo con el algoritmo de busqueda binario, pero se demora un poco y sobre pasa el tiempo de 30 sec que tiene el php como maximo de espera de ejuciocn de un script,

si alguien tiene alguna idea de como poder resolver, consejo, me seria de mucha utilidad

saludos
rodno

[alexg88]

Utiliza la siguiente función para permitir al script ejecutarse durante más tiempo.

Código PHP:

ini_set('max_execution_time', 300); //300 segundos
 

o esta:

Código PHP:

set_time_limit(300);
 

[rodno]

hola, gracias por la respuesta, ese podria ser unas de los consejos que voy a tomar,
pero en realidad lo que me interesa es un algoritmo que busqueda optimo que consuma lo menos recurso posibles.

uno que he probado es el algortimo de busqueda binario, ordeno el el reultado de la consulta,
"el divide la cantidad
entre dos, y compara el valor buscado, y verifica si utiliza la lista superior o inferior"


saludos y gracias

[alexg88]

El algoritmo de búsqueda binaria es de los mejores (sino el mejor) cuando los datos están ordenados, así que no creo que encuentres otro más rápido.

Supongo que la ordenación del resultado la haces en la propia consulta sql, si no es así mejor hazlo.

[rodno]

si, lo hago en la misma consulta, lo no me hice explicar bien,

lo que voy a tener que hacer acortar los limites de los resultados de los recordset para ver si gano en velocidad de respuesta,

cualquier otra sugerencia se admite

[rodno]

hola, mira como lo implemente, o lo mejor tengo algun error y por eso se me demora

Código PHP:

                                      $limit_search=round($rs_datos_destino->RecordCount()/2,0);
                                    echo $limit_search;
                                    while (!$rs_datos_origen->EOF)
                                    {
                                       //$rs_datos_destino->fields[3];
                                      // while ($i<10)
                                       //{
                                        
 
                                            $i++;
                                            
                                            $flag_compare=false;
                                            $rs_datos_destino->Move($limit_search);
                                            if ($rs_datos_destino->fields[3]==$rs_datos_origen->fields[0])
                                                $flag_compare=true;
                                            else
                                            if ($rs_datos_destino->fields[3]>$rs_datos_origen->fields[0]) 
                                                {
                                                 //$limit_search=round($limit_search/2,0);
                                                 //echo $limit_search." mayor \n";
                                                 $rs_datos_destino->MoveFirst();
                                                 for ($k=0;$k<$limit_search;$k++)
                                                    {
                                                    if ($rs_datos_destino->fields[3]==$rs_datos_origen->fields[0])
                                                       {
                                                        $flag_compare=true;
                                                        $k=$limit_search;
                                                       }
                                                       //echo "inferior \n";
                                                   $rs_datos_destino->MoveNext();    
                                                    }
                                                }
                                            else //Busqueda 
                                                {
                                                //$limit_search=round(($rs_datos_destino->RecordCount()-$limit_search)/2,0); 
                                                
                                                 $rs_datos_destino->MoveNext();
                                                 
                                                  while (!$rs_datos_destino->EOF || $flag_compare!=true)
                                                      {
                                                      //echo " superior \n";  
                                                      if ($rs_datos_destino->fields[3]==$rs_datos_origen->fields[0])
                                                         $flag_compare=true;
                                                       $rs_datos_destino->MoveNext();    
                                                      }
                                                }
     
                                      $rs_datos_origen->MoveNext();  
                                   } 
   

[alexg88]

Yo ahí no veo una búsqueda binaria, más bien parece una búsqueda secuencial (mucho más lenta), aunque puedo estar equivocado.

Normalmente una búsqueda binaria se realiza mediante recursión (por supuesto, se puede realizar una versión iterativa).