Wat zijn de belangrijkste verschillen tussen een gekoppelde lijsten en een BinarySearchTree? Is BST gewoon een manier van het handhaven van een LinkedList? Mijn instructeur sprak over LinkedList en vervolgens BST maar did't vergelijken of niet zeggen wanneer een over een andere voorkeur. Dit is waarschijnlijk een domme vraag, maar ik ben echt in de war. Ik zou het waarderen als iemand dit op een eenvoudige manier kunnen verduidelijken.
Verschil tussen een LinkedList en een binaire zoekboom
stemmen
28
De vraag is gesteld op 06/11/2008 om 21:13 2008-11-06 21:13
bron van user ashokgelal
In andere talen...
bron van user ashokgelal
In andere talen...
13 antwoorden
stemmen 8
8
Ik zou zeggen dat het belangrijkste verschil is dat een binaire zoekboom wordt gesorteerd. Wanneer u in een binaire zoekboom, waar die elementen uiteindelijk worden opgeslagen in het geheugen in te voegen is een functie van hun waarde. Met een gekoppelde lijst worden elementen blindelings toegevoegd aan de lijst, ongeacht hun waarde.
Meteen kunt u een aantal trade offs: Linked lijsten behouden inbrengen orde en invoegen is minder duur Binary zoeken bomen zijn over het algemeen sneller te zoeken
stemmen 12
12
In de informatica, een binaire zoekboom (BST) is een binaire boom datastructuur die de volgende eigenschappen heeft:
- elk knooppunt (object tree) een unieke waarde;
- zowel links en rechts substructuren moeten ook binaire zoekboom zijn;
- de linker deelboom van een knoop bevat waarden lager dan de waarde van het knooppunt;
- de rechter deelboom van een knoop bevat waarden groter dan of gelijk aan de waarde van het knooppunt.
In de informatica, een gekoppelde lijst is een van de fundamentele datastructuren, en kan worden gebruikt om andere data structuren uit te voeren.
Dus een binaire zoekboom is een abstract concept dat met een gekoppelde lijst of een matrix kan worden geïmplementeerd. Terwijl de gelinkte lijst is een fundamentele datastructuur.
stemmen 5
5
Gelinkte lijsten en BSTS niet echt veel met elkaar gemeen, behalve dat ze allebei datastructuren die fungeren als containers. Gelinkte lijsten in principe kunt u in te voegen en efficiënt te verwijderen elementen op een locatie in de lijst, met behoud van de volgorde van de lijst. Deze lijst wordt geïmplementeerd met behulp van pointers van het ene element naar het volgende (en vaak ook de vorige).
Een binary search boom aan de andere kant is een data structuur van een hoger abstractieniveau (dwz het is niet gespecificeerd hoe dit intern wordt geïmplementeerd) dat zorgt voor een efficiënte zoekopdrachten (dat wil zeggen met het oog op een specifiek element vind je hoeft niet te kijken naar alle de elementen.
Merk op dat een gelinkte lijst kan worden gezien als een gedegenereerde binaire boom, dat wil zeggen een boom waar alle knooppunten hebben slechts één kind.
stemmen 71
71
Linked List:
Item(1) -> Item(2) -> Item(3) -> Item(4) -> Item(5) -> Item(6) -> Item(7)
Binaire boom:
Node(1)
/
Node(2)
/ \
/ Node(3)
RootNode(4)
\ Node(5)
\ /
Node(6)
\
Node(7)
In een gekoppelde lijst, worden de items met elkaar verbonden door middel van een enkele volgende pointer. In een binaire boom, kan elke node 0, 1 of 2 subnodes, waarbij (bij een binaire zoekboom) de sleutel van de linker knooppunt minder dan de sleutel van het knooppunt en de sleutel van het juiste knooppunt meer dan het knooppunt. Zolang de boom in balans is, de SearchPath om elk item is een stuk korter dan die in een gekoppelde lijst.
Searchpaths:
------ ------ ------
key List Tree
------ ------ ------
1 1 3
2 2 2
3 3 3
4 4 1
5 5 3
6 6 2
7 7 3
------ ------ ------
avg 4 2.43
------ ------ ------
Door grotere structuren de gemiddelde zoekpad wordt aanzienlijk kleiner:
------ ------ ------
items List Tree
------ ------ ------
1 1 1
3 2 1.67
7 4 2.43
15 8 3.29
31 16 4.16
63 32 5.09
------ ------ ------
stemmen 1
1
Een binaire zoekboom kan op elke wijze worden uitgevoerd, is het niet nodig om een gekoppelde lijst te gebruiken.
Een gekoppelde lijst is slechts een structuur die knooppunten en pointers / verwijzingen naar andere knooppunten in een knooppunt bevat. Gezien het hoofd knooppunt van een lijst, kunt u bladeren naar een ander knooppunt in een gekoppelde lijst. Dubbel-gekoppelde lijst twee pointers / verwijzingen: normaal verwijzing naar het volgende knooppunt, maar ook een verwijzing naar het vorig knooppunt. Als de laatste knooppunt in een dubbel-gelinkte lijst verwijst naar het eerste knooppunt in de lijst de volgende knooppunt en het eerste knooppunt verwijst naar de laatste knoop als vorig knooppunt, wordt gezegd dat een cirkelvormige opsomming.
Een binaire zoekboom is een boom die verdeelt zijn ingang in twee gelijke helften Ruw basis van een binary search vergelijkingsalgoritme. Er is dus slechts een paar zoekopdrachten om een element te vinden. Bijvoorbeeld, als je een boom gehad met 1-10 en je nodig hebt om te zoeken naar drie, eerst het element aan de top zou worden gecontroleerd, waarschijnlijk een 5 of 6. Drie minder zou zijn dan dat, dus alleen de eerste helft van de boom zou dan worden gecontroleerd. Als de volgende waarde 3 is, heb je het, anders is, een vergelijking wordt gedaan, etc, totdat het is niet gevonden of als de gegevens worden geretourneerd. Zo is de boom is snel voor lookup, maar is niet noodzakelijkerwijs snel voor het inbrengen of verwijderen. Deze zijn zeer ruwe beschrijvingen.
Gelinkte lijst van wikipedia, en Binary Search Tree , ook van wikipedia.
stemmen 3
3
Een gekoppelde lijst is alleen dat ... een lijst. Het is lineair; elk knooppunt heeft een verwijzing naar het volgende knooppunt (en de vorige, als je praat over een dubbel-gelinkte lijst). Een boomtakken --- elk knooppunt een verwijzing naar verschillende kindknopen. Een binaire boom is een speciaal geval waarbij elke knoop twee kinderen. Dus in een gekoppelde lijst, elk knooppunt heeft een vorig knooppunt en een volgend knooppunt, en in een binaire boom, een knooppunt heeft een linker kind, rechts kind en ouder.
Deze relaties kunnen bi-directionele of uni-directioneel zijn, afhankelijk van hoe je moet in staat zijn om de structuur te doorkruisen.
stemmen 4
4
Het is eigenlijk vrij eenvoudig. Een gekoppelde lijst is enkel een bos van items aan elkaar geketend, in willekeurige volgorde. U kunt denken aan het als een echt mager boom die nooit takken:
1 -> 2 -> 5 -> 3 -> 9 -> 12 -> |i. (Die laatste is een ASCII-art poging tot een afsluitende null)
Een Binary Search Boom verschillend is op 2 manieren: het binaire deel betekent dat elk knooppunt heeft 2 kinderen, niet één, en de zoektocht deel betekent dat die kinderen zijn ingericht om te versnellen zoekopdrachten - alleen kleiner items aan de linkerkant, en alleen grotere naar rechts:
5
/ \
3 9
/ \ \
1 2 12
9 heeft geen links kind, en 1, 2, en 12 "bladeren" - ze hebben geen filialen.
Zinvol?
Voor de meeste "lookup" soorten toepassingen, een BST is beter. Maar voor slechts "het bijhouden van een lijst van dingen om te gaan met later First-In-First-Out of Last-In-First-Out" soort dingen, kan een gekoppelde lijst goed te werken.
stemmen 2
2
Gekoppelde lijst is recht Lineaire gegevens aangrenzende knooppunten met elkaar verbonden zoals A-> B-> C. Je kunt het beschouwen als een rechte hek.
BST is een hiërarchische structuur net als een boom met de hoofdstam verbonden en takken die takken in turn verbonden met andere takken enzovoorts. De "binaire" woord betekent hier elke tak is verbonden met maximaal twee takken.
U gebruikt gekoppelde lijst om direct gegevens uitsluitend met elk item is verbonden met een maximum van één punt te vertegenwoordigen; terwijl u BST kunt gebruiken om een item aan te sluiten op twee punten. U kunt BST gebruiken om een data te representeren, zoals stamboom, maar dat zal n-voudige zoekboom want er kan meer dan twee kinderen aan elke persoon te worden.
stemmen 1
1
Ze zijn totaal verschillend datastructuren.
Een gekoppelde lijst is een opeenvolging van elementen waarbij elk element is gekoppeld aan de volgende, en in het geval van een dubbel gelinkte lijst, de vorige.
Een binaire zoekboom is iets totaal anders. Het heeft een root node, de root node heeft tot twee onderliggende nodes, en elk kind knooppunt kan maximaal twee kinderen notities etc etc. Het is een vrij slimme datastructuur hebben, maar het zou een beetje vervelend zijn om het hier uit te leggen. Check out de Wikipedia artcle op.
stemmen 3
3
Het probleem met een gekoppelde lijst is zoeken binnen deze (al dan niet voor het ophalen of in te voegen).
Voor een enkele-gelinkte lijst, moet je beginnen aan het hoofd en zoek achtereenvolgens om het gewenste element te vinden. Om de noodzaak om de hele lijst te scannen te voorkomen, extra verwijzingen naar de knooppunten moet u binnen de lijst, in welk geval, het is niet langer een eenvoudige gelinkte lijst.
Een binaire boom zorgt voor een snellere zoeken en aanbrengen door inherent gesorteerde en navigeerbaar.
Een alternatief dat ik met succes heb gebruikt in het verleden is een SkipList. Dit zorgt voor iets wat lijkt op een gekoppelde lijst, maar met extra verwijzingen naar laten zoeken prestaties die vergelijkbaar zijn met een binaire boom.
stemmen 6
6
Een gekoppelde lijst is een opeenvolgend aantal "nodes" met elkaar verbonden, namelijk:
public class LinkedListNode
{
Object Data;
LinkedListNode NextNode;
}
Een Binary Search Boom maakt gebruik van een soortgelijke knooppunt structuur, maar in plaats van te koppelen aan het volgende knooppunt, verbindt twee kind nodes:
public class BSTNode
{
Object Data
BSTNode LeftNode;
BSTNode RightNode;
}
Door het volgen van specifieke regels bij het toevoegen van nieuwe knooppunten om een BST, kunt u een datastructuur die zeer snel te doorkruisen te creëren. Andere antwoorden hier hebben deze regels uitgewerkt, ik wilde alleen maar om te laten zien op de code-niveau het verschil tussen het knooppunt klassen.
Het is belangrijk op te merken dat als je gesorteerde gegevens in een BST te voegen, zul je eindigen met een gekoppelde lijst, en je verliest het voordeel van het gebruik van een boom.
Hierdoor een LinkedList een O (N) traversal gegevensstructuur, terwijl een BST is een O (N) traversal gegevensstructuur in het ergste geval, en O (log N) in het beste geval.
stemmen 16
16
Een binaire zoekboom een binaire boom, waarin elke interne knoop x slaat een element dat is opgeslagen in de linker deelboom van het element x minder dan of gelijk aan x en elementen die in de rechter deelboom van x groter dan of gelijk aan x .
Nu een gekoppelde lijst bestaat uit een reeks van knooppunten, die elk willekeurige waarden en één of twee referenties wijzen op de volgende en / of voorgaande knooppunten.
stemmen 3
3
Ze hebben wel overeenkomsten, maar het belangrijkste verschil is dat een binaire zoekboom is ontworpen om efficiënt zoeken naar een element of "sleutel" te ondersteunen.
Een binaire zoekboom, als een dubbel-gelinkte lijst, wijst op twee andere elementen in de structuur. Echter, bij het toevoegen van elementen van de structuur, in plaats van ze toe te voegen aan het einde van de lijst, de binaire boom is gereorganiseerd zodat elementen in verband met de "links" knooppunt zijn dan het huidige knooppunt en elementen in verband met de "juiste" knooppunt groter zijn dan het huidige knooppunt.
In een eenvoudige uitvoering wordt het nieuwe element ten opzichte van het eerste element van de structuur (de wortel van de boom). Als het minder, dan wordt de "linkse" tak genomen, anders is het "juiste" tak wordt onderzocht. Dit gaat met elk knooppunt, tot een vertakking blijkt leeg te zijn; het nieuwe element vervult die positie.
Met deze eenvoudige aanpak, als elementen worden toegevoegd in orde is, eindig je met een gekoppelde lijst (met dezelfde prestaties). Er bestaan verschillende algoritmen voor het behoud van een zekere mate van evenwicht in de boom, door een herschikking knooppunten. Bijvoorbeeld, AVL bomen doen het meeste werk om de boom zo evenwichtig mogelijk te houden, waardoor de beste zoektijden. Rood-zwarte bomen niet de boom in balans te houden, wat resulteert in een iets tragere zoekopdrachten, maar minder werk te doen op gemiddeld als sleutels worden geplaatst of verwijderd.