punerea în aplicare a BST

Question

punerea în aplicare a BST

voturi

1

Ce e în neregulă cu următoarea punerea în aplicare a unui căutare arbore binar (BST) ? Mi sa spus că este mai bine să utilizați pointer la un pointer la structnodul ca argument în funcție de inserție.

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

Întrebat 13/01/2010 la 11:01
sursa de către utilizator Amol Aggarwal

În alte limbi...

3 răspunsuri

voturi

1

Atunci când un nod este inserat (frunze == 0), nu a schimbat mamă, astfel încât noul nod va deveni un orfan.

Cu alte cuvinte, copacul se va arăta în continuare ca un singur nod, indiferent de cât de multe noduri au fost numite cu inserție.

Publicat 13/01/2010 la 12:32
sursa de către utilizator Francis

voturi

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

Publicat 04/10/2013 la 14:31
sursa de către utilizator Prakher Agarwal

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

Această linie:

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

dă o nouă valoare leaf, arătând - o la o parte din memorie alocată nou. Cu toate acestea, noua valoare nu părăsește funcția. Când funcția returnează, apelantul va fi în continuare referindu -se la cele vechi leaf, și va exista o scurgere de memorie.

Există două abordări ai putea lua pentru fixarea acestuia:

1. Folosiți un pointer la un pointer, de exemplu ,

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. Întoarceți noua frunze (sau frunze vechi în cazul în care nu există nici o schimbare).

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

Trimiteri către indicii sunt aproape de pragul de a fi greu de înțeles. Mi - ar merge , probabil , pentru a doua opțiune, în cazul în care insertnu se întoarce în prezent , nimic altceva.