implementatie BST

Question

implementatie BST

stemmen

1

Wat is er mis met de volgende implementatie van een binaire zoekboom (BST) ? Ik heb te horen gekregen dat het beter is om pointer gebruiken om een pointer naar structhet knooppunt als een argument in insert-functie.

struct node
{
int key_value;
struct node* left;
struct node* right;
};

insert(int key, struct node *leaf)
{
    if( leaf == 0 )
    {
        leaf = (struct node*) malloc( sizeof( struct node ) );
        leaf->key_value = key;
        /* initialize the children to null */
        leaf->left = 0;    
        leaf->right = 0;  
    }
    else if(key < leaf->key_value)
    {
        insert( key, leaf->left );
    }
    else if(key > leaf->key_value)
    {
        insert( key, leaf->right );
    }
}

c implementation binary-search-tree

De vraag is gesteld op 13/01/2010 om 11:01
bron van user Amol Aggarwal

In andere talen...

3 antwoorden

stemmen

1

Wanneer een knooppunt is geplaatst (blad == 0), heb je niet de moedermaatschappij veranderen, zodat het nieuwe knooppunt zal een wees geworden.

Met andere woorden, zal uw boom nog steeds uitzien als slechts één knooppunt, ongeacht hoeveel nodes werden genoemd met insert.

antwoordde op 13/01/2010 om 12:32
bron van user Francis

stemmen

-2

  #include<stdio.h>
     typedef struct tnode{
       int data;
       struct tnode *left,*right;
     }TNODE;
     TNODE * createTNode(int key){
       TNODE *nnode;
       nnode=(TNODE *)malloc(sizeof(TNODE));    
       nnode->data=key;
       nnode->left=NULL;
       nnode->right=NULL;
      return nnode;
}

    TNODE * insertBST(TNODE *root,int key){
     TNODE *nnode,*parent,*temp;
     temp=root;
      while(temp){
        parent=temp;
        if(temp->data > key)
            temp=temp->left;
        else
            temp=temp->right;    
    }    
     nnode=createTNode(key);
    if(root==NULL)
        root=nnode;
    else if(parent->data>key)
        parent->left=nnode;
    else
        parent->right=nnode;
    return root;
}

     void preorder(TNODE *root){
       if(root){
         printf("%5d",root->data);    
         preorder(root->left);
         preorder(root->right);
       }    
     }  

    void inorder(TNODE *root){
       if(root){
        inorder(root->left);
        printf("%5d",root->data);    
        inorder(root->right);
      }    
    }

    void postorder(TNODE *root){
       if(root){
        postorder(root->left);    
        postorder(root->right);
        printf("%5d",root->data);
      }    
    }

     main(){
       TNODE *root=NULL;
       int ch,key;
       do{
         printf("\n\n1-Insert\t2-Preorder\n3-Inorder\t4-Postorder\n5-Exit\n");
         printf("Enter Your Choice: ");
         scanf("%d",&ch);  

        switch(ch){ 
            case 1:
                printf("Enter Element: ");
                scanf("%d",&key);
                root=insertBST(root,key);
                break;
            case 2:
                preorder(root);
                break;
            case 3:
                inorder(root);
                break;
            case 4:
                postorder(root);
                break;
            default:
                printf("\nWrong Choice!!");
        }

    }while(ch!=5);
    getch();
    return 0;
}

antwoordde op 04/10/2013 om 14:31
bron van user Prakher Agarwal

Edmund · Accepted Answer · 2010-01-13 12:48

Deze lijn:

leaf = (struct node*) malloc( sizeof( struct node ) );

geeft een nieuwe waarde leaf, wijzend op een bepaald nieuw toegewezen geheugen. Echter, de nieuwe waarde niet de functie te verlaten. Wanneer de functie terugkeert, zal de beller nog steeds verwijzen naar de oude leaf, en zal er een geheugenlek zijn.

Er zijn twee benaderingen die u zou kunnen nemen om hem vast te zetten:

1. Gebruik een pointer naar een pointer, bv

void insert(int key, struct node **leaf)
{
    if(*leaf == 0 )
    {
        *leaf = (struct node*) malloc( sizeof( struct node ) );
        ...
}

/* In caller -- & is prepended to current_leaf. */
insert(37, &current_leaf);

2. Zet de nieuw blad (of de oude blad als er geen verandering).

struct node *insert(int key, struct node *leaf)
{
    if(leaf == 0 )
    {
        leaf = (struct node*) malloc( sizeof( struct node ) );
        ...
    }

    return leaf;
}

/* In caller -- & is prepended to current_leaf. */
current_leaf = insert(37, current_leaf);

Pointers naar pointers zijn dichtbij de drempel van het zijn moeilijk te begrijpen. Ik zou waarschijnlijk gaan voor de tweede optie, zo insertis op dit moment niet iets anders terug te keren.