El rincón de Zerial » Documentacion http://blog.zerial.org Informática, GNU/Linux, Seguridad, Hacking, Programación, Ocio Tue, 20 Jul 2010 18:13:34 +0000 en hourly 1 http://wordpress.org/?v=3.0 Migración de datos en Drupal http://blog.zerial.org/linux/documentacion/migracion-exportacion-importacion-datos-drupal/ http://blog.zerial.org/linux/documentacion/migracion-exportacion-importacion-datos-drupal/#comments Fri, 02 Oct 2009 01:25:14 +0000 Zerial http://blog.zerial.org/?p=926 drupal_migra Drupal 6 nos provee de una API que nos permitirá trabajar directamente con el core, usando las funciones, módulos y configuraciones ya existentes. De esta forma, y gracias a los hooks, podemos realizar distintas funciones tales como agregar, eliminar y modificar usuarios y contenidos, manejar los comentarios, configuraciones, etc.
La idea de este artículo es ayudar a las personas que necesiten realizar una migración (importación/exportación) desde un sistema distinto hacia Drupal.

Las funciones que necesitamos de la API de Drupal son:

  1. user_save(): Permite la manipulación de los usuarios.
  2. node_save(): Manipulación de los nodos (contenidos).
  3. db_query(): Nos permite realizar consultas a la base de datos usando la configuración de Drupal.

Con estas funciones ya podemos pensar en realizar una migración total o partial de un sitio. La lógica del asunto es sencilla, tenemos que hacer un “wrapper” que conecte ambas plataformas (hablando de base de datos y ficheros), hacer que por un lado se conecte a la base de datos de la plataforma antigua y por otro lado a Drupal, que vaya leyendo los datos desde la plataforma antigua y luego insertandolos en la nueva plataforma usando las funciones de la API, por ejemplo, si tenemos la tabla usuarios con los tipicos campos nombre, email, usuario, password, en Drupal la estructura de la tabla {users} es similar, contiene los campos email, name y pass (los que nos sirven) entre otros. Entonces lo que debemos hacer es un pequeño script que haya un SELECT email, password, usuario FROM usuarios y hacer que cada registro que lea, lo inserte en la tabla {users} mediante la API (función user_save()).
Ejemplo:

  1. $var1 = mysql_query("SELECT email,password,usuario FROM usuarios", $link);
  2. while($data = mysql_fetch_array($var1)){
  3.    $userdata = array(
  4.                         ‘status’ => 1,
  5.                         ‘name’ => $data[‘usuario’],
  6.                         ‘pass’ => ’123′,
  7.                         ‘picture’ => $_avatar,
  8.                         ‘mail’ => $data[‘email’],
  9.                 );
  10.                 user_save(”, $userdata);
  11. }

El tema de la contraseña es más complicado, va a depender únicamente de que si la contraseña está en texto plano o encriptada en la base de datos de origen. Si esta en texto plano, entonces basta con agregar al arreglo userdata el valor $data['password'] a la variable pass. De lo contrario, tendremos que hacer un pequeño truco. Creamos el usuario asignandole una clave fake, por ejemplo 123456 y posteriormente, usando la función db_query, hacemos el UPDATE necesario para cambiarle el password al usuario creado, ingresando directamente el HASH original (pensando que esta en md5).

Para realizar la migración de contenido, el procedimiento es de la misma forma, seleccionar la información de un lado y llevarla a otra usando la función node_save.
Si algo se nos escapa de las manos y no sabemos como hacerlo, basta con que entendamos el modelo de la base de datos e ingresemos directamente las consultas a la base de datos (no lo recomiendo).

Hace unos días me tocó la tarea de realizar la migración de una plataforma X a Drupal, para esto diseñe una clase que me permite hacer la migración paso por paso.

  1. < ?php
  2.  
  3. chdir("api/");
  4. include_once ‘api/includes/bootstrap.inc’;
  5. drupal_bootstrap(DRUPAL_BOOTSTRAP_FULL);
  6. flush();
  7.  
  8. class Drupal{
  9.         private $user;
  10.         private $id_uid;
  11.  
  12.         public $counter;
  13.  
  14.         public function __construct(){
  15.                 $this->id_uid = array();
  16.                 $this->counter = array(‘users’ => 0, ‘news’ => 0, ‘comments’ => 0);
  17.                 $this->clearDatabase();
  18.         }
  19.         public function clearDatabase(){
  20.                 $_queries = array(
  21.                         ‘users’ => ‘DELETE FROM dp_users WHERE name != \’admin\’ AND name != \’asdf\’‘,
  22.                         ‘nodes’ => ‘DELETE FROM dp_node WHERE type NOT IN (\’intro\’, \’adminpage\’)’,
  23.                         ‘comments’ => ‘DELETE FROM dp_comments’,
  24. //                      ‘terms_rel’ => ‘DELETE FROM dp_term_node’,
  25. //                      ‘terms’ => ‘DELETE FROM dp_term_data WHERE tid NOT IN (3, 6)’,
  26.                         ‘groups’ => ‘DELETE FROM dp_og’,
  27.                         ‘groups_uid’ => ‘DELETE FROM dp_og_uid’,
  28.                         ‘groups_ancestry’ => ‘DELETE FROM dp_og_ancestry’,
  29.                         ‘groups_notifications’ => ‘DELETE FROM dp_og_notifications’,
  30.                         ‘dp_job_posting’ => ‘DELETE FROM dp_job_posting’,
  31.                         ‘dp_job_posting_country’ => ‘DELETE FROM dp_job_posting_country’,
  32.                 );
  33.                 foreach($_queries as $query){
  34.                         print ">>[DP_SQL] ".$query."\n";
  35.                         db_query($query);
  36.                 }
  37.         }
  38.         public function createUser($data){
  39.                 $_avatar_base_path = "sites/default/files/pictures/";
  40.                 $_avatar = ($data[‘avatar’] == "usuarioSinAV.jpg")?NULL:$_avatar_base_path.$data[‘avatar’];
  41.                 $_user = array(
  42.                         ‘status’ => 1,
  43.                         ‘access’ => time(),
  44.                         ‘name’ => $data[‘username’],
  45.                         ‘pass’ => ’123′,
  46.                         ‘picture’ => $_avatar,
  47.                         ‘profile_nombres’ => $data[‘nombres’],
  48.                         ‘profile_apellido’ => $data[‘apellidos’],
  49.                         ‘profile_intereses’ => $data[‘about’],
  50.                         ‘profesion’ => $data[‘profesion’],
  51.                         ‘mail’ => $data[‘email’],
  52.                 );
  53.                 $user = user_save(”, $_user);
  54.                 self::_setPassword($user->uid, $data[‘password’]);
  55. //              self::_setUserRole($user->uid);
  56.                 self::_configureProfile($data, $user->uid);
  57.                 if($data[‘admin’]) self::_setAdmin($user->uid);
  58.                 $this->user = &$user;
  59.                 $this->id_uid[$data[‘id’]] = $user->uid;
  60.                 $this->counter[‘users’]++;
  61.         }
  62.         public function createContent($data, $type){
  63.                 $node = new stdClass();
  64.                 $node->type = $type;
  65.                 $node->uid = $this->user->uid;
  66.                 $node->name = $user->user->name;
  67.                 $node->promote = 1;
  68.                 $node->format = FILTER_FORMAT_DEFAULT;
  69.                 $node->status = 1;
  70.                 $node->title = html_entity_decode($data[‘titulo’]);
  71.                 $node->body = $data[‘cuerpo’];
  72.                 $node->taxonomy = self::_convertTaxonomy();
  73.                 $node->comment = 2;
  74.                 $node->created = strtotime($data[‘fecha’]);
  75.                 print ">>[node:".$type."] ".substr($node->title, 0, 30)."… (".substr($node->body, 0, 20)." …) [tax:{".implode(";", $node->taxonomy)."},uid:".$node->uid."]\n";
  76.                 $this->counter[‘news’]++;
  77.                 node_save($node);
  78.                 $q = "INSERT INTO dp_node_access(nid, grant_view, realm) VALUES((SELECT MAX(nid) FROM dp_node),1, ‘all’)";
  79.                 db_query( $q );
  80.         }
  81.         public function insertCommentProfile($data){
  82.                 print ">>[comment;autor:".$this->id_uid[$data['autor']].",uid:".$data['userid']."] (".rtrim(substr($data[‘comentario’], 0, 30))." …)\n";
  83.                 db_query("INSERT INTO {comments} (pid, uid, hostname, comment, status, name, mail, homepage, timestamp) VALUES(%d, %d, ‘%s’, ‘%s’, %d, ‘%s’, ‘%s’, ‘%s’, %d)", $data[‘userid’], $this->id_uid[$data[‘autor’]], ’127.0.0.1′, $data[‘comentario’], 1, ”, ”, ”, time());
  84.                 $this->counter[‘comments’]++;
  85.         }
  86.  
  87.         private function _convertTaxonomy($taxonomy = NULL){
  88.                 $_categories = array();
  89.                 $_categories[] = 29;
  90.                 $_categories[] = 30;
  91.                 $_categories[] = 31;
  92.                 $_categories[] = 32;
  93.                 $_categories[] = 33;
  94.                 $_categories[] = 34;
  95.                 $_categories[] = 35;
  96.                 return array( ($taxonomy)?$_categories[–$taxonomy]:35 );
  97.         }
  98.         private function _setPassword($id, $md5){
  99.                 $query = "UPDATE dp_users SET pass = ‘".$md5."’ WHERE (name != ‘asdf’ AND name != ‘admin’) AND uid = ".$id;
  100.                 print ">>[DP_SQL] ".$query."\n";
  101.                 db_query($query);
  102.         }
  103.         private function _setAdmin($id){
  104.                 $table = "dp_users_roles";
  105.                 //$query = "UPDATE ".$table." SET rid = 4 WHERE uid = ".$id; # 4 es el que corresponde segun SELECT * FROM dp_role
  106.                 $query = "INSERT INTO ".$table."(rid, uid) VALUES(4, ".$id.")"; # 2 es el que corresponde segun SELECT * FROM dp_role
  107.                 print ">>[DP_SQL] ".$query."\n";
  108.                 db_query($query);
  109.         }
  110.         private function _setUserRole($id){
  111.                 $table = "dp_users_roles";
  112.                 $query = "INSERT INTO ".$table."(rid, uid) VALUES(2, ".$id.")"; # 2 es el que corresponde segun SELECT * FROM dp_role
  113.                 print ">>[DP_SQL] ".$query."\n";
  114.                 db_query($query);
  115.         }
  116.         private function _configureProfile($info, $_uid){
  117.                 $uid = $info[‘id’];
  118.                 $query = "SELECT a.nombre_esp FROM cat_paises a LEFT JOIN usr_users b ON b.pais = a.id WHERE b.id = ".$uid;
  119.                 $_r = mysql_result(sqlExec($query, ‘query’), 0, ‘nombre_esp’);
  120.                 db_query("INSERT INTO dp_profile_values(fid, uid, value) VALUES(8, ".$_uid.", ‘".$_r."’)");
  121.  
  122.                 $query = "SELECT a.nombre_esp FROM paises a LEFT JOIN users b ON b.pais_residencia = a.id WHERE b.id = ".$uid;
  123.                 $_r = mysql_result(sqlExec($query, ‘query’), 0, ‘nombre_esp’);
  124.                 db_query("INSERT INTO dp_profile_values(fid, uid, value) VALUES(9, ".$_uid.", ‘".$_r."’)");
  125.  
  126. /*                $query = "SELECT a.profesion FROM users a WHERE a.id = ".$uid;
  127.                 $_r = mysql_result(sqlExec($query, ‘query’), 0, ‘profesion’);
  128.                 db_query("INSERT INTO dp_profile_values(fid, uid, value) VALUES(3, ".$_uid.", ‘".$_r."’)");*/
  129.  
  130.                 $query = "SELECT a.nombre FROM cat_usr a LEFT JOIN usr_users b ON b.categoria = a.id WHERE b.id = ".$uid;
  131.                 $_r = mysql_result(sqlExec($query, ‘query’), 0, ‘nombre’);
  132.                 db_query("INSERT INTO dp_profile_values(fid, uid, value) VALUES(4, ".$_uid.", ‘".$_r."’)");
  133.  
  134.                 $query = "SELECT a.subcategoria_es FROM areas_ciencia_subcat a, usr_users b WHERE b.area_ciencia_subcat != 0 AND b.area_ciencia_subcat = a.id_subcat AND b.id = ".$_uid;
  135.                 if($_r = mysql_result(sqlExec($query, ‘query’), 0, ‘subcategoria_es’)){
  136.                         db_query("UPDATE dp_profile_values SET value = ‘".$_r."’ WHERE fid = 7 AND uid = ".$_uid);
  137. //                      db_query("INSERT INTO dp_profile_values(fid, uid, value) VALUES(7, ".$_uid.", ‘".$_r."’)");
  138.                 }
  139.         }
  140. }

Esta clase nos permite crear una instancia para trabajar con Drupal y de esta forma poder migrar usuarios, contenidos, asignar taxonomias/categorias, resetear claves, insertar comentarios, etc. Cada método público debe ser llamado pasando como argumento un array con la información que desea ser insertada. Por ejemplo, una llamda al método createUser:

  1. $_users = mysql_query("SELECT * FROM usuarios", $link);
  2. while($_users_row = mysql_fetch_array($_users)){
  3.         // Llamada a API drupal para crear usuario
  4.         $drupal->createUser($_users_row);
  5. }

Sencillamente, lo que hace este pedazo de código es consultar en una base de datos por todos los usuarios y posteriormente, por cada registro encontrado, llamar al método “createUsers” pasándole como argumento el row correspondiente al ciclo.

Les dejo el script “Migrar.php” que instancia la clase Drupal y hace uso de sus métodos:

  1. < ?php
  2. /*
  3.  * Lunes, 21 de Septiembre del 2009.
  4.  *
  5.  * Migrador de plataformas para
  6.  * Drupal.
  7.  *
  8.  */
  9.  
  10. // Config
  11. require_once("Config.php");
  12.  
  13. $conexion = mysql_connect($host, $username, $password) OR die("Error al conectar a la base de datos.\n");
  14.  
  15. // Llamada a nuestro wrapper
  16. require_once("Drupal.class.php");
  17.  
  18. if(!mysql_select_db($database, $conexion)){
  19.         print "Error al seleccionar la base de datos.\n";
  20. }
  21. else{
  22.         $start = time();
  23.         $drupal = new Drupal();
  24.        
  25.         // Usuarios
  26.         $table = "usr_users";
  27.         $query = "SELECT * FROM ".$table;
  28.         $_users = sqlExec($query, "print_query");
  29.         getRows($_users);
  30.         while($_users_row = mysql_fetch_array($_users)){
  31.                 // Llamada a API drupal para crear usuario
  32.                 $drupal->createUser($_users_row);
  33.                 // Fin
  34.                 $table = "infoc_news";
  35.                 $query = "SELECT * FROM ".$table." WHERE autor = ".$_users_row[‘id’]." ORDER BY fecha";
  36.                 $_news = sqlExec($query, "print_query");
  37.                 getRows($_news);
  38.                 while($_news_row = mysql_fetch_array($_news)){
  39.                         // Llamada a API drupal para crear contenido
  40.                         $drupal->createContent($_news_row, "news");
  41.                         // Fin
  42.                 }
  43.         }
  44.        
  45.         // Comentarios en perfiles
  46.         $table = "usr_comments";
  47.         $query = "SELECT * FROM usr_coments WHERE responseTo = 0";
  48.         $_comments = sqlExec($query, "print_query");
  49.         getRows($_comments);
  50.         while($_comments_row = mysql_fetch_array($_comments)){
  51.                 // Llamada a API drupal para insertar comentarios en perfiles
  52.                 $drupal->insertCommentProfile($_comments_row);
  53.                 // FIn
  54.         }
  55.         $stop = time();
  56.         $time = $stop – $start;
  57.         print "Migration done.\n";
  58.         print "+ Summary:\n";
  59.         print "|- Users:\t".$drupal->counter[‘users’]."\n";
  60.         print "|- Nodes:\t".$drupal->counter[‘news’]."\n";
  61.         print "|- Comments:\t".$drupal->counter[‘comments’]."\n";
  62.         print "|_ Time:\t".date("s", $time)." secs.\n";
  63. }
  64. /* sqlExec()
  65.  * Ejecuta y/o imprime una consulta SQL
  66.  */
  67. function sqlExec($query, $type){
  68.         global $conexion;
  69.         switch($type){
  70.                 case ‘print’:
  71.                         print ">>[SQL] ".$query."\n";
  72.                         break;
  73.                 case ‘query’:
  74.                         return mysql_query($query, $conexion);
  75.                         break;
  76.                 case ‘print_query’:
  77.                         print ">>[SQL] ".$query."\n";
  78.                         return mysql_query($query, $conexion);
  79.                         break;
  80.                 case ‘default’:
  81.                         print "Error en el modo de trabajo.\n";
  82.                         break;
  83.         }
  84.         return NULL;
  85. }
  86.  
  87. /* getRows()
  88.  * Imprime la cantidad de resultados obtenidas desde una consulta
  89.  */
  90. function getRows($resource){
  91.         print "< < ".mysql_num_rows($resource)." rows.\n";
  92. }
  93. ?>

NOTA Estos scripts son los originales que he usado para migrar una plataforma, si alguien quiere darle un uso personal debe hacer las modificaciones correspondientes que se adapten a su propio modelo de datos y a sus propias necesidades.

Delicious Twitter Facebook Google Bookmarks FriendFeed Digg Slashdot Compartir/Guardar

]]> http://blog.zerial.org/linux/documentacion/migracion-exportacion-importacion-datos-drupal/feed/ 0 Validar correctamente la subida de un archivo con php http://blog.zerial.org/seguridad/php-validar-subida-fichero/ http://blog.zerial.org/seguridad/php-validar-subida-fichero/#comments Thu, 04 Jun 2009 17:09:52 +0000 Zerial http://blog.zerial.org/?p=333 Cuando nos enfrentamos a esta situación se nos viene a la cabeza distintas formas de querer validar un fichero, según sea la necesidad; por tamaño, extension, etc.
Lo que voy a explicar es como realizar la una validación correcta y eficiente del tipo de archivo que se está subiendo y aprovecho de explicar tambien la importancia de realizar bien esta validación.

Antes que todo, hay que tener en claro como funciona esto de la subida de archivos y tener en mente que la validación se puede y debe hacerse a nivel de cliente y a nivel de servidor. Muchas veces me he enfrentado a situaciones donde el desarrollador solo hace la validación a nivel de cliente, en javascript. Por ejemplo, así:

  1. <script>
  2. function validar(archivo){
  3.    var b = archivo.split(‘.’);
  4.    if(b[b.length-1] == ‘txt’)
  5.       return true;
  6.    else{
  7.       alert(‘Error: El archivo debe ser .txt’);
  8.       return false;
  9.    }
  10. }</script>

Si llamamos a esa función pasando como parámetro archivo.txt no mostrara ningún error, de lo contrario, si pasamos otro argumento como pelicula.avi devolverá error y no nos dejará continuar.
Este tipo de validación es el menos eficiente, ya que realizar una petición por POST sin pasar por el formulario es algo muy simple, basta con tener las herramientas necesarias como por ejemplo curl.
Hay que dejar en claro que el hecho de validar un formulario unicamente en javascript es una gran irresponsabilidad, ya sea la validación de unos simples datos como los típicos nombres, apellidos, email hasta la subida de archivos. El realizar una validación por javascript nos entrega una capa más de seguridad, pero no la única.

Cuando realizamos un upload, para que el archivo pueda ser validado y procesado a nivel de servidor (php), es necesario que el archivo exista fisicamente en el servidor, es decir, que ya se haya subido, lo que no significa que vaya a ser publicado.

ciclo de validacion

La validación correcta para el tipo de un archivo es mediante mime-type y no mediante su extension, ya que cambiarla es muy simple. El mime-type viene impregnado en las cabeceras del archivo y php es capáz de acceder a ellas cuando el fichero se encuentra en nuestro directorio temporal (ver imágen).
Cuando ya hemos realizado el upload, antes de realizar la operación mode_uploaded_file() debemos hacer la validación por su mime:

  1. < ?php
  2. $_FILES[‘nombreDelCampo’][‘type’];
  3. ?>
  4.  

En esa variable se guardara el mimetype del fichero que ya hemos subido y que, actualmente, esta en nuestro directorio temporal. Los tipos de mimes pueden ser:

[...]
image/jpeg
image/png
image/gif
text/plain
application/octet-stream
audio/mpeg3
application/msword
[...]

Lista más completa de MimeTypes.

La importancia de realizar una validación correcta es sensilla, nos pueden meter un caballo de troya, es decir, subir un fichero que tenga extension .jpg pero que en realidad sea un .mp3. Si nos basamos solamente en la validacion javascript, será muy facil saltarnos esa validacion y subir un fichero con la extension que nosotros queramos, por ejemplo un .php “maligno” que nos permita una shell remota via web o algún fichero .exe con algún virus o troyano que queramos difundir.
Un ejemplo claro es lo que pasó en este caso, donde alguien subio a un servidor un fichero .exe infectado que luego empezo a propagarlo vía email usando un dominio supuestamente fiable.

Delicious Twitter Facebook Google Bookmarks FriendFeed Digg Slashdot Compartir/Guardar

]]> http://blog.zerial.org/seguridad/php-validar-subida-fichero/feed/ 0 Virtualizacion usando Xen http://blog.zerial.org/linux/documentacion/virtualizacion-usando-xen/ http://blog.zerial.org/linux/documentacion/virtualizacion-usando-xen/#comments Sun, 20 Jan 2008 01:05:02 +0000 Zerial http://blog.zerial.org/2008/01/19/virtualizacion-usando-xen/ Hasta hace unos dias solo habia probado la Virtualizacion usando vmware pero hace unos dias me puse a trabajar e investigar sobre Xen y hay varias cosas que me llamaron la atencion, su modo de trabajar, los conceptos que emplea, la facilidad y versatilidad, etc.

Bueno, en resumen Xen es una herramienta de virtualizacion que usa el mecanismo de paravirtualizacion y nos permite cambiar de un sistema operativo a otro en caliente (sin necesidad de apagar o reiniciar la maquina), ademas de cambiarle varias configuraciones (por ejemeplo la ram) en caliente tambien. A nivel de procesador, el sistema operativo se ejecuta en una capa o nivel superior a la de los programas, bueno, Xen despacha de ese nivel al sistema operativo quedando el en ese nivel. Se dice que el sistema operativo es el supervisor de los programas que se ejecutan, pues Xen es nuestro Hipervisor (que esta por sobre el supervisor), es quien ‘supervisa’ al supervisor, es decir, un rango mas alto … Se podria decir que el sistema operativo se ejecuta sobre Xen.

Por ejemlpo, cuando uno esta en un sistema operativo puede abrir y cerrar aplicaciones, iamgen eso pero abriendo y cerrando segun el antojo de cada uno los sistemas operativos.
Esta caracteristica se logra modificando el codigo fuente de nuestro sistema operativo, por lo que solo en sistemas de codigo abierto se puede instalar, como el Kernel de Linux. Intel y AMD han colaborado con todo este desarrollo de la
virtualizacion y como es en el caso de Windows, que es un sistema de codigo cerrado, no se podria virtualizar. Pues Intel y AMD desarrollaron procesadores con capacidad de correr el sistema operativo en otro nivel, sin necesidad de modificar el codigo, dando la posibilidad de virtualizar cualquier sistema operattivo.

Una de las preguntas que me hicieron fue

O sea, Xen en Linux funciona en cualquier pc, Xen con Windows requiere
procesadores con soporte para virtualización… Eso es?

En teoria, segun lo dicho anteriormente deberia ser asi, ya que Microsoft no da acceso al codigo fuente de Windows, pero si Microsoft colaboro con este proyecto para que si se pudiera (a ellos tambien les ayudaria).

Delicious Twitter Facebook Google Bookmarks FriendFeed Digg Slashdot Compartir/Guardar

]]> http://blog.zerial.org/linux/documentacion/virtualizacion-usando-xen/feed/ 1 Algoritmos de ordenamiento http://blog.zerial.org/linux/documentacion/algoritmos-de-ordenamiento/ http://blog.zerial.org/linux/documentacion/algoritmos-de-ordenamiento/#comments Thu, 22 Nov 2007 00:29:32 +0000 Zerial http://blog.zerial.org/2007/11/21/algoritmos-de-ordenamiento/ Por motivos de estudio, he estado durante unos dias investigando sobre los distintos metodos de ordenamiento. Imaginemos un vector o una matriz con numeros o letras (o palabras) desordenadas u ordenadas, los algoritmos de ordenamiento nos permite ordenar en distinto orden los elementos de nuestro vector o matriz. Cada algoritmo tiene distinta complejidad.

Existen algoritmos o metodos simples como el conocido “Burbuja” o “Bubble”, siendo algo tan facil de entender y de escribir, existen tres versiones, una mas eficiente que otra, donde el tiempo de ejecucion o de ordenacion puede reducir hasta “n” veces. (donde n es la cantidad e elementos). Existen metodos aun mas eficientes y usando la tecnica de recursion podemos llegar a ordenar millones de elementos en menos de 1 segundo, como el conocido como “Ordenamiento Rapido” o “Quicksort”.

He hecho un informe o trabajo de investigacion comparando y explicando distintos tipos de ordenamiento. El lenguaje de programacion que he usado para los algoritmos y el para medir el tiempo de ejecucion es Java.

Descargar Documento (Informe):
PDF

Delicious Twitter Facebook Google Bookmarks FriendFeed Digg Slashdot Compartir/Guardar

]]> http://blog.zerial.org/linux/documentacion/algoritmos-de-ordenamiento/feed/ 4