Pre-ordine + post-ordine per in-order


11

Compito

Dati gli attraversamenti pre-ordine e post-ordine di un albero binario completo, restituisci il suo attraversamento in ordine.

Gli attraversamenti saranno rappresentati come due elenchi, entrambi contenenti n interi positivi distinti, ciascuno identificando in modo univoco un nodo. Il tuo programma può prendere questi elenchi e generare il risultante attraversamento in ordine, usando qualsiasi formato I / O ragionevole.

È possibile supporre che l'input sia valido (ovvero, gli elenchi in realtà rappresentano gli attraversamenti di alcuni alberi).

Questo è , quindi vince il codice più breve in byte.

definizioni

Un albero binario completo è una struttura finita di nodi , rappresentata qui da interi positivi unici.

Un albero binario completo è una foglia , costituita da un singolo nodo :

                                      1

O un ramo , costituito da un nodo con due sottotitoli (chiamati sottotitoli sinistro e destro ), ciascuno dei quali è, a sua volta, un albero binario completo:

                                      1
                                    /   \
                                  …       …

Ecco un esempio completo di un albero binario completo:

                                        6
                                      /   \
                                    3       4
                                   / \     / \
                                  1   8   5   7
                                     / \
                                    2   9

L' attraversamento del preordine di un albero binario completo è definito in modo ricorsivo come segue:

  • L'attraversamento del preordine di una foglia contenente un nodo n è l'elenco [ n ].
  • L'incrocio di pre-ordine di un ramo che contiene un nodo n e sotto-alberi (L, R) è l'elenco [ n ] +  preordine ( L ) +  preordine ( R ), dove + è l'operatore di concatenazione elenco.

Per l'albero sopra, questo è [6, 3, 1, 8, 2, 9, 4, 5, 7] .


La traversata post ordine di un albero binario completo è definita in modo ricorsivo come segue:

  • La traversata post ordine di una foglia contenente un nodo n è la lista [ n ].
  • L' incrocio post ordine di un ramo contenente un nodo n e sotto-alberi (L, R) è l'elenco postordine ( L ) +  postordine ( R ) + [ n ].

Per l'albero sopra, questo è [1, 2, 9, 8, 3, 5, 7, 4, 6] .


L' incrocio in ordine di un albero binario completo è definito ricorsivamente come segue:

  • La traversata in ordine di una foglia contenente un nodo n è la lista [ n ].
  • L'incrocio in ordine di un ramo contenente un nodo n e sotto-alberi (L, R) è l'elenco inorder ( L ) + [ n ] +  inorder ( R ).

Per l'albero sopra, questo è [1, 3, 2, 8, 9, 6, 5, 4, 7] .


In conclusione: data la coppia di liste [6, 3, 1, 8, 2, 9, 4, 5, 7] (pre) e [1, 2, 9, 8, 3, 5, 7, 4, 6] (post) come input, il tuo programma dovrebbe produrre [1, 3, 2, 8, 9, 6, 5, 4, 7] .

Casi test

Ogni caso di test è nel formato preorder, postorder → expected output.

[8], [8] → [8]
[3,4,5], [4,5,3] → [4,3,5]
[1,2,9,8,3], [9,8,2,3,1] → [9,2,8,1,3]
[7,8,10,11,12,2,3,4,5], [11,12,10,2,8,4,5,3,7] → [11,10,12,8,2,7,4,3,5]
[1,2,3,4,5,6,7,8,9], [5,6,4,7,3,8,2,9,1] → [5,4,6,3,7,2,8,1,9]

Dato che l'input ha una forma specifica (un albero binario completo), non hai davvero bisogno di entrambi gli input, vero?
feersum,

L'albero binario è pieno , ma non completo , quindi un albero a n elementi può avere molte forme e, in generale, sono necessari entrambi.
Lynn,

Vorrei rappresentare i nodi come singole lettere che forniscono stringhe per gli ordini. Ad esempio il secondo esempio diventerebbe "CDE" and "DEC" give "DCE":? (anche usando lettere unicode se ho bisogno di molti nodi)
Ton Hospel il

@TonHospel Starei bene con questo - probabilmente, tutto ciò che stai facendo è allungare un po ' la definizione di un elenco di numeri interi , perché "CDE"non è molto diverso da [67, 68, 69]:)
Lynn,

Risposte:


2

Perl, 69 66 62 56 53 byte

Include +1 per -p

Accetta il postordine seguito dal preordine come una riga separata dallo spazio su STDIN (notare l'ordine di pre e post). I nodi sono rappresentati come lettere univoche (qualsiasi carattere che non sia spazio o newline è OK).

inpost.pl <<< "98231 12983"

inpost.pl:

#!/usr/bin/perl -p
s%(.)(.)+\K(.)(.+)\3(\1.*)\2%$4$5$3$2%&&redo;s;.+ ;;

L'uso del formato puramente numerico originale richiede molta più attenzione per identificare esattamente un singolo numero e arriva a 73 byte

#!/usr/bin/perl -p
s%\b(\d+)(,\d+)+\K,(\d+\b)(.+)\b\3,(\1\b.*)\2\b%$4$5,$3$2%&&redo;s;.+ ;;

Usare come

inpostnum.pl <<< "11,12,10,2,8,4,5,3,7 7,8,10,11,12,2,3,4,5"

-paggiunge un ;alla fine, quindi non è necessario l'ultimo ;. s;.* ;;->s;.* ;
Riley,

@Riley lo so. Ecco perché ;alla fine ho . Ma -p in realtà aggiunge \n;alla fine in un -eprogramma. In un file aggiunge solo ;se e solo se il file non termina \n. Dal momento che voglio rivendicare -pcome +1 e non +3 il programma deve funzionare dalla riga di comando, quindi con -e. E non voglio la nuova linea spuria nell'output che vorrei ottenere
Ton Hospel,

Se lo esegui dalla riga di comando non ti serve 'intorno? Se lo esegui nel modo in cui lo hai (chiama un file con <<<) puoi lasciare l'ultimo ;spento.
Riley,

@Riley Dipende dall'interpretazione del metodo di punteggio per il perl. Di solito invio il mio codice come file poiché penso che sia meno effimero. Ma se guardi i miei invii vedrai che se il codice deve essere in un file (perché ad esempio ha 'o usa do$0ecc.) Punteggio sempre -pcome +3 (spazio, meno, p), ma se anche il codice funzionasse sulla riga di comando dove ottieni il -ee il 'gratis lo +1e
segnalo

Ok, non ero chiaro su come segnassero gli invii da riga di comando. Non mi ero reso conto che ricevi 'gratis. Grazie per averlo chiarito.
Riley,

3

Haskell, 84 83 byte

(a:b:c)#z|i<-1+length(fst$span(/=b)z),h<- \f->f i(b:c)#f i z=h take++a:h drop
a#_=a

2

JavaScript (ES6), 100 byte

f=(s,t,l=t.search(s[1]))=>s[1]?f(s.slice(1,++l+1),t.slice(0,l))+s[0]+f(s.slice(l+1),t.slice(l)):s[0]

L'I / O è in stringhe di caratteri "sicuri" (ad es. Lettere o cifre). Approccio alternativo, anche 100 byte:

f=(s,t,a=0,b=0,c=s.length-1,l=t.search(s[a+1])-b)=>c?f(s,t,a+1,b,l)+s[a]+f(s,t,l+2+a,l+1,c-l-2):s[a]
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.