BST implementering

Question

BST implementering

stemmer

1

Hva er galt med følgende gjennomføringen av et binært søketre (BST) ? Jeg har blitt fortalt at det er bedre å bruke pekeren til en peker til structnode som et argument i innsettingsfunksjon.

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

Publisert på 13/01/2010 klokken 10:01
kilden bruker Amol Aggarwal

På andre språk...

3 svar

stemmer

1

Når en node er satt inn (blad == 0), gjorde du ikke endre sin forelder, slik at den nye noden vil bli en foreldreløs.

Med andre ord, vil treet fortsatt ser ut som bare en node, uansett hvor mange noder ble kalt med innsatsen.

Svarte 13/01/2010 kl. 11:32
kilden bruker Francis

stemmer

-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;
}

Svarte 04/10/2013 kl. 13:31
kilden bruker Prakher Agarwal

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

Denne linjen:

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

gir en ny verdi til leaf, peker det på et nylig tildelte minnet. Men den nye verdien ikke forlate funksjonen. Når funksjonen returnerer, vil den som ringer fortsatt henvise til den gamle leaf, og det vil være en minnelekkasje.

Det er to tilnærminger du kan ta for å fikse det:

1. Bruk en peker til en peker, f.eks

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. Sett nytt blad (eller den gamle bladet hvis det er ingen endring).

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);

Pekere til pekere er nær grensen for å være vanskelig å forstå. Jeg vil trolig gå for det andre alternativet, hvis insertikke tiden tilbake noe annet.