BST Umsetzung

Question

BST Umsetzung

stimmen

1

Was ist los mit der folgenden Implementierung eines binären Suchbaum (BST) ? Ich habe gesagt, dass es besser ist , Zeiger auf einen Zeiger zu verwenden , um structals Argument - Funktion in Insert - Knoten.

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

Veröffentlicht am 13/01/2010 um 11:01
quelle vom benutzer Amol Aggarwal

In anderen Sprachen...

3 antworten

stimmen

1

Wenn ein Knoten (Blatt == 0) eingesetzt ist, haben Sie nicht ihre Mutter ändern, so dass der neue Knoten wird eine Waise geworden.

Mit anderen Worten, wird immer noch Ihr Baum wie ein nur Knoten aussehen, egal wie viele Knoten mit Einsatz genannt wurden.

Beantwortet am 13/01/2010 um 12:32
quelle vom benutzer Francis

stimmen

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

Beantwortet am 04/10/2013 um 14:31
quelle vom benutzer Prakher Agarwal

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

Diese Linie:

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

gibt einen neuen Wert leaf, es irgend neu zugewiesenen Speicher zeigt. Allerdings ist der neue Wert die Funktion nicht verlassen. Wenn die Funktion zurückkehrt, wird nach wie vor der Anrufer auf die alte Bezugnahme leaf, und es wird ein Speicherverlust sein.

Es gibt zwei Ansätze, die Sie zur Festsetzung es dauern könnte:

1. Verwenden einen Zeiger auf einen Zeiger, zum Beispiel

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. Bringen Sie das neue Blatt (oder das alte Blatt , wenn es keine Veränderung).

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

Zeiger auf Zeiger sind in der Nähe der Schwelle zu begreifen schwer zu sein. Ich würde wahrscheinlich für die zweite Option gehen, wenn insertderzeit nichts anderes zurück.