如何在C中实现没有递归的二叉搜索树的删除功能？

Question

I try to implement the delete method but that doesn't work with me. I want to delete all nodes in the tree. The function has tree type of "struct tree" as a parameter so I can't use recursion; I want to do it with a loop.

That's my structure

    typedef struct Node Node;
    struct Node{
        const void* data;
        const void* value; 
        Node* left;
        Node* right;
    };

    typedef struct Tree Tree;
    struct Tree{
        Node* root;
        size_t size;
        int (*comp)(const void *, const void *);
    };

function delete

    void freeTree(Tree* tree, bool TreeContent){
        if(tree->root != NULL){

            // free(tree->root->left);
            // free(tree->root->right);
            // free(tree->root);
        }
    }              

function insert

bool insertInTree(Tree* bst, const void* key, const void* value){
    if(bst->root == NULL){
            Node* newNode = (Node*) malloc(sizeof(Node));
            if(newNode == NULL){
                   printf("erreur d'allocation dynamique \n");
                   exit(1);
            }
            newNode->left =  newNode->right = NULL;
            newNode->value = value;
            newNode->data = key;
            return true;
    }
    else{
            int isLeft = 0 ;
            Node* Current = bst->root ;
            Node* precedant = NULL;
            while(Current != NULL){
                int compare = bst->comp(&Current->data , &key);
                precedant = Current;
            if(compare == 1){
                   isLeft = 1;
                   Current = Current->left;
            }
            else if(compare == 0){
                    isLeft = 0;
                    Current = Current->right;
            }

            }
            if(isLeft == 1){
                    Node* newNode = (Node*) malloc(sizeof(Node));
                    if(newNode == NULL){
                                       printf("erreur d'allocation dynamique \n");
                                       exit(1);
                    }
                    newNode->left =  newNode->right = NULL;
                    newNode->value = value;
                    newNode->data = key;
                    precedant->left = newNode;
                    bst->size++;
                    return true;
                    }
            else{
                    Node* newNode = (Node*) malloc(sizeof(Node));
                    if(newNode == NULL){
                                       printf("erreur d'allocation dynamique \n");
                                       exit(1);
                    }

                    newNode->left =  newNode->right = NULL;
                    newNode->value = value;
                    newNode->data = key;
                    precedant->right = newNode;
                    bst->size++;
                    return true;

            }

        }
        return false;
}

Answer 1

edit You don't want to use recursion because the freeTree function doesn't take a Node argument. In this case, you can remove that restriction by creating another function that is recursive, called initially by freeTree .

void freeTree(Tree* tree, bool TreeContent){
    if(tree->root != NULL){
        freeNode(tree->root);
        tree->root = NULL;
    }
}            

The new freeNode could look like

void freeNode(Node *node) {
    if (node->left) freeNode(node->left);
    if (node->right) freeNode(node->right);
    free(node);
}

Note that freeNode intent is to free the whole tree (otherwise the parent element's left or right [or root] would have to be set to NULL).

Answer 2

Your requirement is that you don't want to use recursion.

Any kind of traversal is not possible in O(n) time without use of a stack/queue (implicitly or explicitly). So we will use a stack (made using an array) and use it to delete all the nodes.

I understand that you have the size of the BST known, so you can create an array of appropriate size as -

struct Node* stack[bst->size];
int top = -1;

This stack will hold all the elements to be processed.

We will first add the root to the stack -

if(bst->root)
    stack[++top] = bst->root;

Now we need to process all the nodes in the tree using a loop -

while(top>=0){
    //Pop one node - 
    struct Node* node = stack[top--];
    //Add its children to the stack;
    if(node->left)
        stack[++top] = node->left;
    if(node->right)
        stack[++top] = node->right;
    // Now free the node as 
    free(node);
}

That is all, one by one each node will be added to the stack and the stack will become empty when all the nodes are done.

Also as a side note, in your insert function you need to do bst->size++ in the if(bst->root == NULL) branch. Else your size will be one less than actual number of nodes.