Ordenación en padres-hijos

[matabyte]

Buenas!

Pues estoy liado con un problema que me lleva un par de días y no le veo solución (debe de ser de esas cosas que tienes delante de tus narices pero no salen hasta que les da la gana).

La cosa es que tengo una lista de ficheros que tienen todos un path común inicial (digamos "/BACKUP/"). Como por ejemplo:

/BACKUP/uno/fichero.dat
/BACKUP/uno/fichero2.dat
/BACKUP/dos/fichero.dat
/BACKUP/dos/tres/fichero.dat
/BACKUP/cuatro/cinco/fichero.dat

Quería hacer una lista con todos los directorios en forma de arbol, con una estructura tal que el directorio hijo apunte al padre.

La estructura en la quería meter los datos es algo así:

Código Delphi [-]
type
  Tdirectorio = record
                       nombre:widestring;
                       directorio_padre:longword; //Este apunta al número del directorio padre de esta misma estructura.
                       nombre:widestring;
                    end;
var
  tabla_directorios:array of tdirectorio;
  num_tabla_directorios:longword;

El primer registro del array "tabla_directorios" es el raiz o el directorio común báse.

La cosa es que me estoy comiendo la cabeza para teniendo los nombres y rutas de los ficheros, como recorrerlos para que se almacenen los directorios en la estructura.

No se si me explico bien, es como hacer esto con la lista de los ficheros que he puesto de ejemplo arriba (aunque esto es manualmente y no automáticamente):

Código Delphi [-]
  tabla_directorios[0].nombre:='';
    tabla_directorios[0].directorio_padre:=0;
    tabla_directorios[1].nombre:='BACKUP';
    tabla_directorios[1].directorio_padre:=0;
    tabla_directorios[2].nombre:='uno';
    tabla_directorios[2].directorio_padre:=1;
    tabla_directorios[3].nombre:='dos';
     tabla_directorios[3].directorio_padre:=1;
     tabla_directorios[4].nombre:='tres';
      tabla_directorios[4].directorio_padre:=3;
      tabla_directorios[5].nombre:='cuatro';
       tabla_directorios[5].directorio_padre:=1;
       tabla_directorios[6].nombre:='cinco';
       tabla_directorios[6].directorio_padre:=5;

Si alguien sabe como hacerlo, por favor, podéis ayudarme?, gracias.

[[duilioisola]]

Supongo que primero deberías ver las funciones FindFirst y FindNext de Delphi para poder obtener información de archivos y directorios.

Luego de posicionarte en el directorio raiz (/BACKUP/) lees todos los directorios.
A cada uno lo agregas a tu registro indicándole directorio_padre=0

Para cada registro que has agregado, haces lo mismo que antes, para los directorios que tiene dentro.

Otra forma es utilizando recursividad:


Me posiciono en el directorio raiz.
Leo el primer directorio
Agrego este directorio a la estructura
Vuelvo a hacer esto pero teniendo en cuenta que el directorio raiz es raiz+directorio
Leo el siguiente directorio

[matabyte]

Gracias por la respuesta.

El problema es que los datos que tengo no son indicaciones de directorios en si, es un array de strings conteniendo una lista de archivos.

Si serían directorios sería facil

Sigo trabajando en el problema

[matabyte]

Vale, ya lo he conseguido, pongo la solución por si alguien necesita también algo parecido:

La estructura que contiene la lista de directorios es:

Código Delphi [-]
 type
  Tdirectorio = record
    nombre: widestring;
    path:widestring;
    anterior: longword;
    path_completo: widestring;
  end;

var
iso_for:record
             tabla_path:array of Tdirectorio;
             tabla_path_num:longword;
             num_directoriosANSI: longword;
             directoriosANSI: array of Tdirectorio;
          end;

Y la solución para extraterlo:

Código Delphi [-]
     ISO_for.tabla_path_num:=1;
     setlength(ISO_for.tabla_path,ISO_for.tabla_path_num);
     ISO_for.tabla_path[ISO_for.tabla_path_num-1].anterior:=1;
     ISO_for.tabla_path[ISO_for.tabla_path_num-1].path_completo:='\';
     ISO_for.tabla_path[ISO_for.tabla_path_num-1].nombre:='\';

      for a := 0 to iso_for.num_directoriosANSI - 1 do
       begin
         st:=iso_for.directoriosANSI[a].nombre;
         if st[1]<>'\' then st:='\'+st;
         st2:='';
         for b := length(st) downto 1 do
          begin
            if (st[b]='\') then
             begin
               st2:=Copy(st, 0, b);
               result:=false;
               for c := 0 to ISO_for.tabla_path_num - 1 do
                begin
                  if uppercase(st2)=uppercase(ISO_for.tabla_path[c].path_completo) then
                   begin
                     result:=true;
                     break;
                   end;
                end;
                  if result then
                  else
                   begin
                     inc(ISO_for.tabla_path_num);
                     setlength(ISO_for.tabla_path,ISO_for.tabla_path_num);
                     ISO_for.tabla_path[ISO_for.tabla_path_num-1].path_completo:=st2;
                     for c := length(st2) downto 0 do
                      begin
                        if ((st2[c]='\')and(c<>Length(st2)))or(c=0) then
                         begin
                           if c=0 then
                            begin
                             ISO_for.tabla_path[ISO_for.tabla_path_num-1].anterior:=1;
                             ISO_for.tabla_path[ISO_for.tabla_path_num-1].nombre:=copy(st2,c,Length(st2));
                            end
                           else
                            begin
                             ISO_for.tabla_path[ISO_for.tabla_path_num-1].nombre:=copy(st2,c+1,Length(st2));
                            end;
                           break;
                         end;
                      end;
                   end;
               st2:=st2+'\';
             end;
          end;
       end;


      for b := 1 to ISO_for.tabla_path_num - 1 do
       begin
         //Caculamos el hijo
         st2:=iso_for.tabla_path[b].path_completo;
                     for c := length(st2) downto 0 do
                      begin
                        if ((st2[c]='\')and(c<>Length(st2)))or(c=0) then
                         begin
                           if c=0 then
                            begin
                              iso_for.tabla_path[b].anterior:=1;
                            end
                           else
                            begin
                              st2:=Copy(st2,0,c);
                              for a := 0 to ISO_for.tabla_path_num - 1 do
                               begin
                                 if UpperCase(st2)=UpperCase(iso_for.tabla_path[a].path_completo) then
                                  begin
                                    iso_for.tabla_path[b].anterior:=a;
                                    Break;
                                  end;
                               end;
                            end;
                           break;
                         end;
                      end;
//         richedit1.Lines.Add(iso_for.tabla_path[iso_for.tabla_path[b].anterior].nombre+'  --  '+iso_for.tabla_path[b].nombre);
       end;