Binary Search Tree

Probeer het tekenen van verschillende bomen op een papier en zie wat je krijgt. Herinner dat een binaire boom wordt gedefinieerd als een structuur waarin elk knooppunt kan 0 (waarbij het een blad), 1 of 2 kinderen. Voor uw vraag moet u het zeer onevenwichtige geval van 1 kind per node te onderzoeken.

Overwegen:

Als je probeert om het aantal bladeren te maximaliseren, wil je zo weinig interne knopen mogelijk (en het omgekeerde als je probeert om het aantal bladeren minimaliseren). Hoe kun je dat bereiken?

Om een ​​boom van de maximale hoogte te krijgen, dan heb je zo weinig knooppunten in elk niveau mogelijk te zetten. Hoe kan je dat doen? Omgekeerd, voor de minimale hoogte, wat is het maximum aantal knooppunten kunt u op elk niveau te zetten?

Op hoeveel manieren zijn er om elk knooppunt van een boom te krijgen? Dus, hoeveel pointers heb je nodig?

Ik ga ervan uit dat je ofwel codering in C of C ++.

een. Een knooppunt, indien de structuur wordt gedefinieerd als volgt: struct knooppunt {struct knooppunt * links, rechts *; }; U zult merken dat de structuur van beide kan hebben 0, 1 of 2 bladeren. Dus, de max 2 min is 0 bladeren.

b.Minimal lengte nul, waarbij zou alleen het hoofdknooppunt bevatten. Merk op dat de wortel knooppunt telt niet als een hoogte van 1. Het is ook wel de diepte op keer. Hier is een algoritme voor de hoogte:

    int height(struct node *tree) 
    { 
    if (tree == NULL) return 0;
    return 1 + max (height (tree->left), height (tree->right)); 
    }

Lees meer: http://wiki.answers.com/Q/How_do_you_find_out_the_height_of_a_Binary_Search_Tree#ixzz1NIB17SkL

c. Vergeef me als ik dit de worng manier, maar ik ga ervan uit dat als we dit in kaart gebracht op een stuk papier, zouden we proberen om het aantal "links" dat we zouden gebruiken vinden? In dat geval zou het eenvoudigweg het aantal knooppunten in de boom -1 voor root node. Dit algoritme te vinden op deze pagina http://forums.techarena.in/software-development/1147688.htm kan u helpen: controleer of wortel is null, vervolgens de linker en rechter knooppunten als parameters in de functie.

int countnodes(Node* root)
{
    if (root == null || k<=0)
    {
      return 0;
    } else {
        return 1 + count(root.left,k-1) + count(root.right,k-1);
    }
}
// remember to subtract one at the end.
int totalnodes = countnodes(root) - 1;

d. De tijdcomplexiteit De beste geval O (nlogn) waarin n het aantal knooppunten te voegen. Het ergste geval is O (n). Het ligt direct lineair.

Als u nog andere vragen gewoon google het, er zijn genoeg dingen om te weten over binary search bomen. Maar het grootste deel van het is gewoon recursie dat je kunt leren in 30 seconden.

Ik hoop dat dit helpt. Veel geluk met jouw examen! Ik had mij een paar maanden geleden. ;)