Pointing-Mitglied von Struktur zu Struktur selbst in C

Question

Hier sind zwei Strukturen, die ich verwende. Ich bin mir nicht sicher, wie man initialisiert, damit Mitglied der Struktur auf Struktur selbst zeigt. Ich bin mir nicht sicher, ob das möglich ist oder nicht.

typedef struct __node 
{ 
    int value; 
    struct __node* left; 
    struct __node* right; 
}setNode; 

typedef struct __set { 
    setNode* root; 
    //mutex for this set (To be implemented) 
}set; 

Ich mag Mitglieder der Menge initialisieren, aber nicht sicher, wie soll ich nun tun result->root zur gleichen Adresse wie die set result zu zeigen.

set* new_set() 
{ 
    set* result = malloc(sizeof(set)); 
    result -> root = NULL; // Not sure??? 
} 

Ich möchte den Zeiger auf root bekommen.

void someOther(set* s) 
{ 
    setNode* temp = s -> root; 
    //.... 
} 

Entschuldigung, wenn die Frage zu vage ist.

Additional Info

Ich möchte zwei structs. Eine, die Knoten eines Baumes enthält [setNode] und eine zweite Struktur, die einen Zeiger auf die Wurzel der Baumstruktur und einige andere Elemente enthält (wie Mutex für diesen Baum) [set]. Das ist kein Problem.

Problem: In einer Funktion habe ich setNode* temp = someSet -> root;, so dass ich in der Lage sein sollte, über den Baum zu gehen, d. H. Temp sollte auf root von someSet zeigen. Also, was sollte ich result -> root in new_set-Funktion zuweisen?

Answer 1

Ein leerer Satz enthält keine Elemente. Wenn eine Menge durch einen binären Suchbaum dargestellt wird, ist ein Null-Wurzelzeiger dafür geeignet.

set* new_set() 
{ 
    set* result = malloc(sizeof(set)); 
    result -> root = NULL; // Yes, absolutely positively 100% sure 
    return s; // Don't forget! 
} 

Wenn Sie den Zeiger auf root erhalten möchten, erhalten Sie es.

void someOther(set* s) 
{ 
    setNode* temp = s -> root; 
    //!!!! 
} 

absolut nichts falsch mit temp Wesen NULL. Deine Funktion muss damit umgehen können. Wenn Sie eine rekursive Traversal-Funktion wollen, schreiben Sie eine, die ein setNode* Argument bekommt:

void someOther(set* s) 
{ 
    setNode* temp = s -> root; 
    someOtherDoThisActuallyIMeanItNow (temp); 
} 

void someOtherDoThisActuallyIMeanItNow (setNode* current) 
{ 
    ... 
    if (current) { // <-- here we check that it's not NULL 
     ... 
     someOtherDoThisActuallyIMeanItNow (current->left); 
     ... 
     someOtherDoThisActuallyIMeanItNow (current->right); 
    } else { 
     // do whatever is appropriate for an empty tree/set 
    } 
} 

Wenn Sie eine Funktion benötigen, die rekursiv überquert und modifiziert einen Baum, ein machen, die ein setNode** Argument akzeptiert.

void someOtherWithMutation(set* s) 
{ 
    setNode* temp = s -> root; 
    someOtherWithMutationNow (&temp); // <---- here 
} 

void someOtherWithMutationNow (setNode** current) // <---- here 
{ 
    ... 
    if (*current) { // <-- here we check that it's not NULL 
     ... 
     someOtherDoThisActuallyIMeanItNow ((*current)->left); 
     ... 
     someOtherDoThisActuallyIMeanItNow ((*current)->right); 
     ... 
     if (...) { 
      free (*current); 
      *current = NULL; 
     }   
    } else { 
     // do whatever is appropriate for an empty tree/set 
     ... 
     *current = malloc(sizeof(setNode)); 
     ...   
    } 
}