Breetth-éischt vs Déift-éischt Tree Traversal am Javascript

Wann mir duerch e Bam sichen fir ze fannen ob et e gewësse Node enthält, ginn et zwee Algorithmen déi mir kënne bauen. Mir kënne mam Bam mat enger Breet-Éischt oder Tiefe-Éischt Approche passéieren.

Déi Tiefe-Éischt Method gleeft sou wäit wéi méiglech duerch de Bam ze goen bis et zu engem Doudende kënnt. Eemol wann en en Nullwäerteg huet, fänkt se un der Spëtzt zréck a folgt dee selwechte Prozess.

D'Breet-Éischt Method probéiert seng Bescht sou no wéi méiglech uewen ze bleiwen. Et traitéiert de Bam eng Zeil gläichzäiteg a kuckt all seng Geschwësterknoten un. Et geet weider bis se op déi lescht Reih geet.

Eng einfach Node a Bamsklass opzebauen

D'Node Klass wäert e Konstruktor mat zwee Eegeschafte hunn. Et wäert eng Daten Eegeschafte hunn fir de Wäert vum Node ze späicheren an eng Kanner Eegeschafte fir eng Array vu Kannernode ze halen. D'Method add () kann benotzt ginn fir nei Wirbelen op de Bam ze addéieren an d'Method () ze läschen en ongewollten Kannernode.

Wann mir e Bamsklass bauen, brauche mir nëmmen e Besëtz fir den éischten Node ze weisen, och bekannt als Root.

Bannen an der Bamklass ass wou mir eis DFS an BFS Sich Funktiounen opbauen fir duerch e Bam vun Noden ze sichen.

Déift-Éischt Algorithmus

Fir ze kucken ob e Bam e gewësse Wäert mat der DFS Approche enthält, erstelle mir eng Funktioun déi ufänkt andeems d'Sammlungsarray deklaréiert gëtt, wat de Root Node enthält. Mir wäerten dann eng Weil Bou bauen déi leeft bis et kee Wäert méi bannen an der Array ass.

Den DFS benotzt e Stack fir de Bam vun de Wirbelen duerchzekréien. Mir deklaréieren den aktuellen Node andeems Dir den éischte Wäert vun der Array ofschalt. Mat dësem Node wäerte mir kontrolléieren ob seng Donnéeën gläich ass mam Wäert dee mir sichen. Wa säi Gläich ass, gi mir zréck True an aus der Funktioun eraus. Wann de Wäert vum Node net passt, drécke mir d'Kanner vun deem Node un d'Front vun der Array wa se existéieren. Mir räissen d'Kanner un d'Front well d'DFS Approche wëllt datt mir de ganze Wee bis ënnen vum Bam goen ier iergendeng Schwësterelement préift. Wa kee Wäert entsprécht nodeems de ganze Bam gesucht ass, ginn mir falsch um Enn vun eiser Funktioun zréck.

Breet-Éischt Algorithmus

Nom Bau vun der DFS Funktioun wäert d'BFS Funktioun ganz ähnlech ausgesinn, awer mat engem klengen Ënnerscheed. Wa mir d'BFS Approche benotze, wëlle mir all Schwësterelementer iwwerpréiwen ier mir op déi nächst Zeil vum Bam goen. Mir wäerten et erreechen andeems Dir eng Queue benotzt. D'Quee erfuerdert datt mir d'Pushmethod benotzen anstatt d'Unhiftmethod beim Ëmgang mat de Kanner vum Node. Amplaz d'Kanner vun engem Node ze huelen an se an d'Front vun de Sammlungsarien ze setzen, drécken mer se amplaz. Dëst mécht sécher datt mir all Schwësterelementer iwwerpréiwen ier Dir op déi nächst Zeil vum Bam geet.

Wéini soll Dir BFS vs. DFS benotzen?

Béid Algorithmen kënne praktesch kommen wann Dir duerch e Bam trëppelt fir no engem Wäert ze kucken, awer wéi eng ass besser? Et hänkt alles vun der Struktur vum Bam of a wat Dir sicht. Wann Dir de Wäert wësst, deen Dir sicht no méi no uewen, eng BFS Approche kéint eng super Wiel sinn, awer wann e Bam ganz breed ass an net ze déif, da kann eng DFS Approche méi séier a méi effizient sinn. Bleift nëmmen am Kapp, datt et vill aner Faktore sinn, déi Dir braucht ze bestëmmen ier Dir wielt wéi eng Approche ze huelen. Ech hunn Vertrauen Dir wäert et erausfannen!