En python, une liste convertie en dict comme une topologie arborescente

Avec zip () et itertools.izip_longest () vous pouvez le faire comme:

Code:

{
  "A": [
    "B", 
    "C"
  ], 
  "C": [
    "F", 
    "G"
  ], 
  "B": [
    "D", 
    "E"
  ], 
  "E": [
    "J", 
    "K"
  ], 
  "D": [
    "H", 
    "I"
  ], 
  "G": [
    "N", 
    "O"
  ], 
  "F": [
    "L", 
    "M"
  ], 
  "I": [], 
  "H": [
    "P", 
    "Q"
  ], 
  "K": [], 
  "J": [], 
  "M": [], 
  "L": [], 
  "O": [], 
  "N": [], 
  "Q": [], 
  "P": []
}

Résultats :

import itertools as it

in_data = list('ABCDEFGHIJKLMNOPQ')
out_data = {k: list(v) if v else [] for k, v in
            it.izip_longest(in_data, zip(in_data[1::2], in_data[2::2]))}

import json
print(json.dumps(out_data, indent=2))

Vous pouvez utiliser itertools:

{'A': ['B', 'C'],
 'B': ['D', 'E'],
 'C': ['F', 'G'],
 'D': ['H', 'I'],
 'E': ['J', 'K'],
 'F': ['L', 'M'],
 'G': ['N', 'O'],
 'H': ['P', 'Q'],
 'I': [],
 'J': [],
 'K': [],
 'L': [],
 'M': [],
 'N': [],
 'O': [],
 'P': [],
 'Q': []}

Output:

from itertools import chain, repeat

data = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q']
lists = [[first, second] for first, second in zip(data[1::2], data[2::2])]
result = {char: list(value) for char, value in zip(data, chain(lists, repeat([])))}

result

vous pouvez créer une topologie d'arborescence dict par relation d'index:

def generateTree(arr):
    tree = {}
    for i, v in enumerate(arr):
        tree[v] = []
        if i * 2 + 1 < len(arr):
            tree[v].append(arr[i * 2 + 1])
        if i * 2 + 2 < len(arr):
            tree[v].append(arr[i * 2 + 2])
    return tree

sortie: {'A': ['B', 'C'], 'B': ['D', 'E'], 'C': ['F', 'G'], 'D': ['H', 'I'], 'E': ['J', 'K'], 'F': ['L', 'M'], 'G': ['N', 'O' ], 'H': ['P', 'Q'], 'I': [], 'J': [], 'K': [], 'L': [], 'M': [] , 'N': [], 'O': [], 'P': [], 'Q': []}

J'espère que cela vous aidera, et commentez si vous avez d'autres questions. :)

Voici une méthode à l'ancienne assez optimisée qui utilise la méthode d'indexation de tableau décrite dans le didacticiel suivant: https://www.geeksforgeeks.org/construct-complete-binary-tree-given-array/

La première ligne remplit les non-feuilles avec le valeurs des enfants. La deuxième ligne remplit les feuilles pour être des listes vides. Je noterai que nous savons que le nombre de nœuds internes est (len (valeurs) // 2).

values = ['A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q']
dictionary = {values[i]:[values[2*i+1], values[2*i+2]] for i in range((len(values) // 2))}
dictionary.update({values[i]:[] for i in range((len(values) // 2) + 1, len(values))})

alphabet=['A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q']

d={} # empty dictionary
counter=2
for i in range(0,len(alphabet)):
    if i==0: # at letter 'A' only
        lst=[alphabet[i+1],alphabet[i+2]] # lst that will be used as value of key in dictionary
    elif i<(len(alphabet)-1)/2: #  at letter 'B' through 'H'
        lst=[alphabet[i+counter],alphabet[i+counter+1]] # lst that will be used as value of key in dictionary
        counter+=1 # increment counter

    else: # all letters after 'H'
        lst=[] # an empty list that will be used as value of key in dictionary
    d[alphabet[i]]=lst # add 'lst' as a value for the letter key in the dictionary

print(d) # print the dictionary

# {'A': ['B', 'C'], 'B': ['D', 'E'], 'C': ['F', 'G'], 'D': ['H', 'I'], 'E': ['J', 'K'], 'F': ['L', 'M'], 'G': ['N', 'O'], 'H': ['P', 'Q'], 'I': [], 'J': [], 'K': [], 'L': [], 'M': [], 'N': [], 'O': [], 'P': [], 'Q': []}

essayez ceci:

dd = {}   
for i,e in enumerate(LL):
        LLL   = []
        intv  = (i+1) + len(dd)           
        if (intv < len(LL)): LLL = [LL[(intv)], LL[(intv)+1]]
        dd[e] = LLL

print dd

un peu plus lisible:

LL = ['A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q']

dd = {}
for i,e in enumerate(LL):
    LLL   = []
    if ((i+1) + len(dd) < len(LL)): LLL = [LL[((i+1) + len(dd))], LL[((i+1) + len(dd))+1]]
    dd[e] = LLL

print dd

{'A': ['B', 'C'], 
'B': ['D', 'E'], 
'C': ['F', 'G'], 
'D': ['H', 'I'], 
'E': ['J', 'K'], 
'F': ['L', 'M'], 
'G': ['N', 'O'], 
'H': ['P', 'Q'], 
'I': [], 
'J': [], 
'K': [], 
'L': [], 
'M': [], 
'N': [], 
'O': [], 
'P': [], 
'Q': []}