Quelles combinaisons de séquentialisation avant, après et dans l'ordre sont uniques?

Nous savons après la commande,

post L(x)     => [x]
post N(x,l,r) => (post l) ++ (post r) ++ [x]

et pré-commande

pre L(x)     => [x]
pre N(x,l,r) => [x] ++ (pre l) ++ (pre r)

et traversée dans l'ordre resp. séquentialisation.

in L(x)     => [x]
in N(x,l,r) => (in l) ++ [x] ++ (in r)

On peut facilement voir que ni l'un ni l'autre ne décrit un arbre donné de manière unique, même si nous supposons des clés / étiquettes distinctes deux à deux.

Quelles combinaisons des trois peuvent être utilisées à cette fin et lesquelles ne le peuvent pas?

Les réponses positives devraient inclure un algorithme (efficace) pour reconstruire l'arbre et une preuve (idée) pourquoi il est correct. Les réponses négatives devraient fournir des contre-exemples, c'est-à-dire différents arbres qui ont la même représentation.

Tout d'abord, je suppose que tous les éléments sont distincts. Aucune séquentialisation ne vous dira la forme d'un arbre avec des éléments [3,3,3,3,3]. Il est possible de reconstruire certains arbres avec des éléments en double, bien sûr; Je ne sais pas quelles sont les bonnes conditions suffisantes.

En continuant sur les résultats négatifs, vous ne pouvez pas reconstruire entièrement un arbre binaire à partir de ses séquentialisations pré-commande et post-commande uniquement. [1,2]précommande, [2,1]post-commande doit avoir 1à la racine, mais 2peut être l'enfant de gauche ou l'enfant de droite. Si vous ne vous souciez pas de cette ambiguïté, vous pouvez reconstruire l'arborescence avec l'algorithme suivant:

• Soit le parcours de pré-commande et le parcours de post-ordre. Nous devons avoir , et c'est la racine de l'arbre.$[x_1,\dots,x_n]$$[y_n,\ldots,y_1]$$x_1=y_1$
• $x_2$ est l'enfant le plus à gauche de la racine et est l'enfant le plus à droite. Si , le nœud racine est unaire; récursivement sur et pour construire le sous-arbre unique.$y_2$$x_2 = y_2$$[x_2,\ldots,x_n]$$[y_n,\ldots,y_2]$
• Sinon, soit et les indices tels que et . est le parcours de pré-commande du sous-arbre gauche, celui du sous-arbre de droite, et de même pour les parcours post-ordre. Le sous arbre gauche a éléments, et le sous arbre droit a éléments. Reculez une fois pour chaque sous-arbre. Soit dit en passant, cette méthode se généralise aux arbres avec ramification arbitraire. Avec une ramification arbitraire, découvrez l'étendue du sous-arbre gauche et coupez ses éléments dans les deux listes, puis répétez pour couper le deuxième sous-arbre à partir de la gauche, etc.$i$$j$$x_2 = y_i$$y_2 = x_j$$[x_2,\ldots,x_{j-1}]$$[x_j,\ldots,x_n]$$j-2=n-i+1$$i-2=n-j+1$
  $j-2$

Comme indiqué, le temps d'exécution est avec pire des cas (dans le cas de deux enfants, nous recherchons chaque liste de manière linéaire). Vous pouvez transformer cela en si vous prétraitez les listes pour construire une structure de carte finie des valeurs des éléments aux positions dans les listes d'entrée . Utilisez également un tableau ou une carte finie pour passer des indices aux valeurs; s'en tenir aux indices globaux, de sorte que les appels récursifs reçoivent toutes les cartes et prennent une plage comme argument pour savoir sur quoi agir.$O(n^2)$$\Theta(n^2)$$O(n\,\mathrm{lg}(n))$$n\,\mathrm{lg}(n)$

Avec la traversée en précommande et la traversée en ordre , vous pouvez reconstruire l'arborescence comme suit:$[x_1,\ldots,x_n]$$[z_1,\ldots,z_n]$

• La racine est la tête du parcours de pré-commande .$x_1$
• Soit l'indice tel que . Alors est la traversée dans l'ordre de l'enfant gauche et est la traversée dans l'ordre de l'enfant droit. En fonction du nombre d'éléments, est la traversée en pré-commande de l'enfant gauche et celle de l'enfant droit. Recurse pour construire les sous-arbres gauche et droit.$k$$z_k = x_1$$[z_1,\ldots,z_{k-1}]$$[z_{k+1},\ldots,z_n]$$[x_2,\ldots,x_k]$$[x_{k+1},\ldots,x_n]$

Encore une fois, cet algorithme est comme indiqué, et peut être exécuté dans si la liste est prétraitée dans une carte finie des valeurs aux positions.$O(n^2)$$O(n\,\mathrm{lg}(n))$

La post-commande plus dans l'ordre est bien sûr symétrique.