मुझे ऐसी नेस्टेड सूचियां कैसे मिलेंगी?

Question

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 

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) 

• परिणाम
  nestedList1: [[['bb1'], [['aa3'], 'aa1', 'aa2'], 'aa', 'bb'], 'root']
  nestedList2: [[['cc1'], [[['bb4'], 'bb2', 'bb3'], 'bb1'], [['aa3'], 'aa1', 'aa2'], 'aa', 'bb', 'cc'], 'root']

सभी मैं चाहता हूँ के लिए मिले परिणाम है।

• परिणाम
  nestedList1: [[[['aa3'], 'aa1', 'aa2'], 'aa', ['bb1'], 'bb'], 'root']
  nestedList2: [[[['aa3'], 'aa1', 'aa2'], 'aa', [[['bb4'], 'bb2', 'bb3'], 'bb1'], 'bb', ['cc1'], 'cc'], 'root']

मैं कैसे इस तरह के एक नेस्टेड सूची मिलता है? मुझे एक नेस्टेड सूची चाहिए, जो ऑर्डर-ऑर्डर करने का आदेश दिया गया है।

Answer 1

मूल रूप से, आप सूची को पुन: व्यवस्थित करने के लिए क्या करने की जरूरत: जब भी n वें तत्व एक लेबल है, और n+1 वें तत्व एक sublist है, दो स्वैप। आप क्या कर सकते हैं इस यथा-स्थान में कुछ लाइन में:

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] 

एक नहीं-इन-जगह समाधान के लिए, तुम सिर्फ सूची का एक गहरे प्रतिलिपि बना सकते हैं और उसके बाद का उपयोग करें कि नकल पर ।

Answer 2

मैं यहां लाइन से बाहर हो सकता हूं, या पूरी तरह से बिंदु खो रहा हूं, लेकिन मुझे दावा करना होगा कि मुझे लगता है कि अगर आप प्रत्येक शाखा को पूरी तरह से ब्रांड्स में एकत्र करते हैं तो यह आसान होगा। अर्थात के रूप में एक विशिष्ट प्रत्येक शाखा [जड़ [Branch1] [Branch2],,, ...] लिखने

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

तो फिर तुम सिर्फ रिकर्सिवली प्रत्येक शाखा पत्ते-1, ट्रंक-2 बनाने के लिए क्रम बदल सकते हैं।

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 

संशोधित 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'] 

यह है कि क्या आप के बाद कर रहे थे?

अच्छी साजिश के लिए कौन सी शाखा गहरी है, यह एक अलग विषय है।