εφαρμογή BST

Question

εφαρμογή BST

ψήφοι

1

Τι συμβαίνει με την ακόλουθη εφαρμογή ενός δυαδικού δένδρου αναζήτησης (BST) ; Μου έχουν πει ότι είναι καλύτερο να χρησιμοποιήσετε το δείκτη σε ένα δείκτη προς structτον κόμβο ως επιχείρημα σε λειτουργία ένθετο.

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

Δημοσιεύθηκε 13/01/2010 στις 11:01
πηγή χρήστη Amol Aggarwal

Σε άλλες γλώσσες...

3 απαντήσεις

ψήφοι

1

Όταν ένας κόμβος εισάγεται (φύλλο == 0), δεν αλλάξατε τη μητρική της, έτσι ώστε ο νέος κόμβος θα γίνει ένα ορφανό.

Με άλλα λόγια, το δέντρο σας θα εξακολουθεί να μοιάζει με ένα μόνο κόμβο, δεν έχει σημασία πόσο πολλές κόμβους κλήθηκαν με ένθετο.

Απαντήθηκε 13/01/2010 στις 12:32
πηγή χρήστη Francis

ψήφοι

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

Απαντήθηκε 04/10/2013 στις 14:31
πηγή χρήστη Prakher Agarwal

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

Αυτή η γραμμή:

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

δίνει μια νέα τιμή για την leaf, δείχνοντας ότι σε κάποια νέα κατανομή μνήμης. Ωστόσο, η νέα τιμή δεν αφήνει τη λειτουργία. Όταν η συνάρτηση επιστρέφει, ο καλών θα εξακολουθεί να αναφέρεται στην παλιά leaf, και θα υπάρξει μια διαρροή μνήμης.

Υπάρχουν δύο προσεγγίσεις που θα μπορούσατε να πάρετε για τον καθορισμό αυτό:

1. Χρησιμοποιήστε ένα δείκτη σε ένα δείκτη, π.χ.

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. Επιστρέψτε το νέο φύλλο (ή το παλιό φύλλο, εάν δεν υπάρχει καμία αλλαγή).

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

Δείκτες σε δείκτες βρίσκονται κοντά στο όριο της είναι δύσκολο να κατανοήσει. Θα μάλλον πάει για τη δεύτερη επιλογή, αν insertδεν είναι επί του παρόντος την επιστροφή οτιδήποτε άλλο.