création dossiers en profondeur

[Tramber]

Bonjour à toutes et tous, bien que je doute encore de trouver de nombreuses dames ici.

 

Je cherche à construire une routine qui lise une structure pour créer des dossiers.

Pour l'instant, je tatonne.

Voici mon idée de codage :

Je donne au caractère "-" la clé pour descendre dans l'arbo.

dossier1
dossier2
-sd1
-sd2
--ssd1
--ssd2
-sd3
-sd4
---sssrejet
-sd5
--sd
---sd
----sd
dossier3

Et le résultat.

On note qu'il est possible de descendre d'un niveau à la fois ou de remonter d'un seul coup à un niveau supérieur. Mais il y a rejet lorsque l'on demande à descendre plus d'un niveau d'un seul coup. C'est le principe.

Ce qui donne :

 

En procédural cela donne en gros ceci :

si un élément au même niveau que le précédent, je crée un dossier à ce niveau.

si le niveau descends d'une unité, je crée un sous dossier et attends la suite

si le niveau remonte, ben..., je remonte.

 

Seulement voilà, j'aimerais passer par le traitement d'une liste pour éventuellement pouvoir la traiter facilement.

J'ai pensé à (en oubliant les guillemets) :

'(dossier1 dossier2 (sd1 sd2 (ssd1 ssd2) sd3 sd4 sd5 (sd (sd (sd )))) dossier3)

Est-ce une bonne idée ?

Avez-vous déjà vu des sujets là-dessus ?

Est-ce challengeant de créer une routine qui transforme :

'("dossier1" "dossier2" "-sd1" "-sd2" "--ssd1" "--ssd2" "-sd3" "-sd4" "---sssrejet" "-sd5" "--sd" "---sd" "----sd" "dossier3")

en cette liste ?

[(gile)]

Salut,

 

J'ai retrouvé une petite bibliothèque de fonctions que j'avais faite pour pouvoir utiliser une structure de données en arbre.

En utilisant des listes imbriquées on peut définir un arbre comme une liste de listes d'association de type (clef valeur) dont la clef (car) est le nom du nœud (dossier) et la valeur (cdr) est un arbre ou nil.

 

Les dernières fonctions de cette bibliothèque permettent la conversion (dans les deux sens) entre une représentation en arbre (imbrications) et une représentation en liste "d'adresses complètes".

 

;| Implémentation d'une structure de données en arbre

Un arbre est représenté une liste de listes d'associations (cons clef valeur)
où valeur est un arbre ou nil

N'utiliser les index que sur les arbres triés

(setq tree '(
     ("OneName"
      ("Xampl"
       ("SubName")
       ("SpainIsDifferent")
      )
      ("AAI"
       ("YVivaSanFermín")
       ("VivaElVinoDeRioja")
      )
     )
     ("Another Item"
      ("ILoveMyMom"
       ("MyMomIsLovely")
       ("AndMyCatToo")
      )
      ("MyTaylorIsRich")
     )
    )
)

(setq tree '(
     ("0"
      ("0.0"
       ("0.0.0")
       ("0.0.1")
      )
      ("0.1")
      ("0.2"
       ("0.2.0")
       ("0.2.1")
       ("0.2.2"
	("0.2.2.0")
	("0.2.2.1")
       )
      )
     )
     ("1"
      ("1.0"
       ("1.0.0")
       ("1.0.1")
      )
      ("1.1"
       ("1.1.0")
       ("1.1.1")
      )
     )
    )
)
|;

;; Trie récursivement l'arbre en utilisant la fonction de tri (comme vl-sort)
;; (sortTree tree '<)
(defun sortTree	(lst fun)
 (vl-sort
   (mapcar
     '(lambda (x)
 (if (cdr x)
   (cons (car x) (sortTree (cdr x) fun))
   x
 )
      )
     lst
   )
   '(lambda (x1 x2) (apply fun (list (car x1) (car x2))))
 )
)

;; obtient le noeud à la clé donné
;; (getNode "AAI" tree)
(defun getNode (key tree)
 (if tree
   (cond
     ((assoc key tree))
     ((getNode key (apply 'append (mapcar 'cdr tree))))
   )
 )
)

;; obtient le noeud à l'index donné
;; (getNodeAt '(0 1 1)  tree)
(defun getNodeAt (ind tree)
 (if tree
   (if	(cdr ind)
     (getNodeAt (cdr ind) (cdr (nth (car ind) tree)))
     (nth (car ind) tree)
   )
 )
)

;; obtient la liste des index du noeud
;; (getIndexOf "AAI" tree)
(defun GetIndexOf (node tree / aux1 aux2)
 
 (defun aux1 (ind node tree)
   (if	tree
     (if (assoc node tree)
(reverse (cons (vl-position (assoc node tree) tree) ind))
(aux2 (cons 0 ind) node tree)
     )
   )
 )
 
 (defun aux2 (ind node tree)
   (if	tree
     (cond
((aux1 ind node (cdar tree)))
(T (aux2 (cons (1+ (car ind)) (cdr ind)) node (cdr tree)))
     )
   )
 )
 
 (aux1 nil node tree)
)

;| représentation sous forme de liste de listes de clefs ordonnées (chemins)

arbre : (("A" ("AA") ("AB" ("ABA") ("ABB"))))
liste : (("A" "AA") ("A" "AB" "ABA") ("A" "AB" "ABB"))

(setq lst '(("1" "1.1" "1.1.1")
    ("2")
    ("1" "1.2")
    ("3" "3.2" "3.2.1")
    ("1" "1.1" "1.1.2")
    ("1" "1.3" "1.3.1" "1.3.1.1")
    ("3" "3.2" "3.2.2")
    ("3" "3.1")
    ("1" "1.3" "1.3.1" "1.3.1.2")
    ("3" "3.2" "3.2.3")
   )
)
|;

;; convertit une liste en arbre
;; (lst2tree lst)
(defun lst2tree	(lst)
 (if (car lst)
   (mapcar '(lambda (x)
       (cons x (lst2tree (massoc x lst)))
     )
    (distinct (mapcar 'car lst))
   )
 )
)

;; convertit un arbre en liste
;; (tree2lst tree)
(defun tree2lst	(tree)
 (apply
   'append
   (mapcar
     '(lambda (n)
 (if (cdr n)
   (mapcar
     '(lambda (x) (cons (car n) x))
     (tree2lst (cdr n))
   )
   (list n)
 )
      )
     tree
   )
 )
)

;; concatène une liste de chaînes et un séparateur en une chaine
;; (mapcar '(lambda (l) (lst2str l "\\")) (tree2lst tree))
(defun lst2str (lst sep)
 (apply 'strcat
 (cons (car lst)
       (mapcar (function (lambda (x) (strcat sep x))) (cdr lst))
 )
 )
)

;; obtient la liste des valeurs pour la clé
(defun massoc (key alst)
 (if (setq alst (member (assoc key alst) alst))
   (cons (cdar alst) (massoc key (cdr alst)))
 )
)

;; obtient la liste sans doublons
(defun distinct	(lst)
 (if lst
   (cons (car lst) (distinct (vl-remove (car lst) lst)))
 )
)

[Tramber]

Merci !

Ta représentation de l'arbre est tout à fait intéressante et alternative à mon idée.

Je vais réfléchir car l’accession par clés est possiblement utile.

Ce qui est plus déroutant c'est encore la liste de départ. Telle que tu la construis je vais peut-être tout revoir car pour l'instant j'ai une liste de départ au format bien différent.

Je vais travailler, comme d'hab et surtout depuis que j'ai des enfants, par tranches de 20 minutes :P

Je reviens vers vous !