2016-07-09 6 views
5
variable tree structure 

- nestedList1 variable 

aa3 
| 
aa1  aa2  bb1 
    \ / /
    aa  bb 
     \ /
     root 

- nestedList2 variable 

       bb4 
       | 
aa3   bb2  bb3 
|    \ /
aa1  aa2  bb1 cc1 
    \ / /  | 
    aa  bb   cc 
     \  |  /
       root 


Wie bekomme ich solche verschachtelten Listen?

nestedList1 = ['root', ['aa', ['aa1', ['aa3'], 'aa2'], 'bb', ['bb1']]] 
nestedList2 = ['root', ['aa', ['aa1', ['aa3'], 'aa2'], 'bb', ['bb1', ['bb2', ['bb4'], 'bb3']], 'cc', ['cc1']]] 

def ConvertTraverse(nlist, depth=0): 
    convertlist = [] 
    for leaf in nlist: 
     if isinstance(leaf, list): 
      tmplist = ConvertTraverse(leaf, depth+1) 
      convertlist.insert(0, tmplist) 
     else: 
      convertlist += [leaf] 
    return convertlist 

print ConvertTraverse(nestedList1) 
print ConvertTraverse(nestedList2) 
  • Ergebnis
    nestedList1: [[['bb1'], [['aa3'], 'aa1', 'aa2'], 'aa', 'bb'], 'root']
    nestedList2: [[['cc1'], [[['bb4'], 'bb2', 'bb3'], 'bb1'], [['aa3'], 'aa1', 'aa2'], 'aa', 'bb', 'cc'], 'root']

Alles, was ich will, ist die unten Ergebnisse.

  • Ergebnis
    nestedList1: [[[['aa3'], 'aa1', 'aa2'], 'aa', ['bb1'], 'bb'], 'root']
    nestedList2: [[[['aa3'], 'aa1', 'aa2'], 'aa', [[['bb4'], 'bb2', 'bb3'], 'bb1'], 'bb', ['cc1'], 'cc'], 'root']

Wie erhalte ich eine solche verschachtelte Liste? Ich möchte eine verschachtelte Liste, nach dem Auftrag bestellt werden.

+0

Vielleicht ist es besser, wenn jeder Zweig in Klammern eingeschlossen wird, dh 'nestedList1 = ['root', ['aa', ['aa1', ['aa3']], ['aa2']], [ 'bb', ['bb1']]]] Dann können Sie rekursiv das erste Element bis zum Ende verschieben. Wenn Sie jedoch sicherstellen möchten, dass mit dem tiefsten Schneidezweig etwas mehr Manipulation erforderlich ist. ' – Aguy

Antwort

2

Grundsätzlich, was Sie tun müssen, um die Liste neu zu ordnen: Immer wenn das n Element eine Beschriftung ist und das Element eine Unterliste ist, tauschen Sie die beiden aus. Sie können dies tun in-place in wenige Linie:

def reorder(lst): 
    for i, (cur, nxt) in enumerate(zip(lst, lst[1:])): 
     if isinstance(cur, str) and isinstance(nxt, list): 
      reorder(nxt) 
      lst[i:i+2] = [nxt, cur] 

Für eine nicht-in-place Lösung, können Sie einfach eine tief Kopie der Liste erstellen und dann auf der Kopie verwenden .

0

Ich bin hier vielleicht nicht in der richtigen Linie oder verpasse den Punkt völlig, aber ich riskiere, dass ich denke, dass es einfacher ist, wenn man jeden Zweig vollständig in Klammern sammelt. das heißt jeden Zweig als Unterscheidungs ​​schreiben [root [branch1], [branch2], ...]

nestedList1 = ['root', ['aa', ['aa1', ['aa3']], ['aa2']], ['bb', ['bb1']]] 
nestedList2 = ['root', ['aa', ['aa1', ['aa3']], ['aa2']], ['bb', ['bb1', ['bb2', ['bb4']], ['bb3']]], ['cc', ['cc1']]] 

Dann können Sie einfach rekursiv die Reihenfolge ändern, jeden Zweig Blätter-1, Stamm-2 zu machen.

def recursivereverese(l): 
    if len(l)<=1 or type(l) is not list: 
     return l 
    else: 
     new = [] 
     for k in l[::-1]: 
      new.append(recursivereverese(k)) 
     return new 

Die Ergebnisse auf den modifizierten nestedlists:

In [127]: recursivereverese(nestedList1) 
Out[127]: [[['bb1'], 'bb'], [['aa2'], [['aa3'], 'aa1'], 'aa'], 'root'] 

In [128]: recursivereverese(nestedList2) 
Out[128]: 
[[['cc1'], 'cc'], 
[[['bb3'], [['bb4'], 'bb2'], 'bb1'], 'bb'], 
[['aa2'], [['aa3'], 'aa1'], 'aa'], 
'root'] 

Ist das, was Sie nach waren?

Es ist ein anderes Thema, herauszufinden, welcher Zweig tiefer liegt, um schön zu plotten.

Verwandte Themen