Ezt a kérdést nekem egy interjúban:
tegyük fel, hogy van fent bináris fa, hogyan tud én olyan kimenetet, mint az alábbi
2 7 5 2 6 9 5 11 4
Azt válaszoltam, mint lehet, mi is van egy szinten száma változó, és kinyomtatni az összes elemet egymás szintjének ellenőrzése számláló változó minden csomóponton. Valószínűleg tévedtem.
tud valaki adni anyidea, hogy hogyan tudjuk ezt elérni?
A bejárás a kérdésében hívják level-order traversal, és ez az, hogy hogyan kell ezt csinálni (nagyon egyszerű / tiszta kódrészlet találtam).
Ön alapvetően felhasználása a sorba, és a műveletek sorrendjét fog kinézni:
enqueue F
dequeue F
enqueue B G
dequeue B
enqueue A D
dequeue G
enqueue I
dequeue A
dequeue D
enqueue C E
dequeue I
enqueue H
dequeue C
dequeue E
dequeue H
Mert ez a fa (egyenes Wikipedia):
A kifejezés, amely szint rendű bejárás . Wikipedia írja le egy algoritmust, amely egy sorban :
levelorder(root)
q = empty queue
q.enqueue(root)
while not q.empty do
node := q.dequeue()
visit(node)
if node.left ≠ null
q.enqueue(node.left)
if node.right ≠ null
q.enqueue(node.right)
BFS :
std::queue<Node const *> q;
q.push(&root);
while (!q.empty()) {
Node const *n = q.front();
q.pop();
std::cout << n->data << std::endl;
if (n->left)
q.push(n->left);
if (n->right)
q.push(n->right);
}
Iteratív mélyítése is működik, és memóriát takarít használja, de rovására számítási időt.
Annyit kell tennie, amelyek szélessége bejárást a fa. Itt le van írva, az alábbiak szerint:
Szélességi bejárás: mélységi nem az egyetlen módja annak, hogy menjen át az elemeket a fa. Egy másik módja az, hogy menjen át őket szinten külön-szintet.
Például, minden egyes elem létezik egy bizonyos szinten (vagy mélységének) a fában:
tree
----
j <-- level 0
/ \
f k <-- level 1
/ \ \
a h z <-- level 2
\
d <-- level 3
az emberek, mint a szám a dolgokat kezdődő 0.)
Tehát, ha azt akarjuk, hogy látogassa meg a elemet szint külön-szint (és a bal-jobb, mint rendesen), mi lenne kezdeni a 0. szinten j, akkor megy a szinten 1 f és k, akkor megy a 2-es szintű egy, hidrogénatom, és Z, és végül menj szinten 3 d.
Ez a szint külön-szintű bejárás nevezzük szélességi bejárás, mert felfedezni a szélessége, azaz a teljes szélességét a fa egy adott szinten, mielőtt mélyebbre.
Szeretném használni egy gyűjteményt, például std::list, hogy tárolja az összes eleme a jelenleg nyomtatott szint:
példaként mit tehet egy interjú, ha nem emlékszik / nem tudom a „hivatalos” algoritmus, az első gondolata az volt - átszövi a fa a rendszeres előrendelhető húzva egy szinten pult mentén, fenntartása vektor kapcsolt listák a mutatókat csomópontok egy szinten, pl
levels[level].push_back(&node);
és a végén kinyomtathatja az egyes szinteken.
Ha képesek vagyunk letölteni a következő elem azonos szintjén, készen vagyunk. Mivel a per a korábbi ismeretekkel , akkor érheti el ezeknek az elemeknek a szélessége bejárást.
Most egyetlen probléma az, hogy hogyan ellenőrizhető vagyunk utolsó eleme minden szinten. Emiatt azt kell appending határoló (NULL ebben az esetben), hogy jelölje végén egy szintet.
Algoritmus: 1. Öntsön gyökeret sorban.
2. NULLA sorban.
3. Amíg a sor nem üres
4. x = csel első eleme a sorból
5. Ha x nem NULL
6. x-> rpeer <= legfelső eleme sorban.
7. fel a bal és jobb gyermeke x sorban
8. mást
9. Ha a sor nem üres
10. NULLA sorban
11. végén, ha
a 12. végén, míg
a 13. visszatérés
#include <queue>
void print(tree* root)
{
queue<tree*> que;
if (!root)
return;
tree *tmp, *l, *r;
que.push(root);
que.push(NULL);
while( !que.empty() )
{
tmp = que.front();
que.pop();
if(tmp != NULL)
{
cout << tmp=>val; //print value
l = tmp->left;
r = tmp->right;
if(l) que.push(l);
if(r) que.push(r);
}
else
{
if (!que.empty())
que.push(NULL);
}
}
return;
}