search - binary search/sort tree

#include "stdio.h"
#include "stdlib.h"
#include "string.h"

//What is a Binary Sort Tree?
//1. A BST is either an empty tree or a binary tree with the following characteristics
//2. all elements on left child tree is smaller than root
//3. all elements on right child tree is larger than root
//4. both left and right child are BST in its own right

//Define a node structure in BST
typedef struct _BSTNode {
    int data;
    struct _BSTNode* lchild, *rchild;
}BSTNode, *BSTree;

// searching key in BST tree
// tree: the target BST tree to be searched
// parent: the parent of tree, this is useful only when tree == NULL
// key: key to search
// found: if found key, gives the node else the last node in the search path 
bool SearchBST( BSTree tree, BSTree parent, int key, BSTree* found )
{
    if( tree == NULL )
    {
        //tree is NULL, simply set found = parent
        *found = parent;
        return false;
    }
    else if( key == tree->data )
    {
        //if tree hosts key, set found = tree
        *found = tree;
        return true;
    }
    else if( key < tree->data )
    {
        //if key is smaller, search the left BST
        return SearchBST( tree->lchild, tree, key, found );
    }
    else
    {
        //if key is larger, search the right BST
        return SearchBST( tree->rchild, tree, key, found );
    }   
}

//insert key into BST
//tree: a pointer to the tree
bool InsertBST( BSTree* tree, int key)
{
    BSTree found, temp;
    if( !SearchBST( *tree, NULL, key, &found))
    {
        //if we have not found key, create a new node
        temp = (BSTree)malloc( sizeof(BSTNode));
        temp->data = key;
        temp->lchild = temp->rchild = NULL;     
        if( found == NULL )
        {
            //first scenario, found returns NULL, indicating tree is empty
            *tree = temp;
        }
        else if( key < found->data )
        {
            found->lchild = temp;
        }
        else
        {
            found->rchild = temp;
        }
        return true;
    }
    else
    {
        //if key is found, do nothing and simply return false
        return false;
    }
}

bool DeleteNode( BSTree* node )
{
    BSTree q;
    if( (*node)->rchild == NULL )
    {
        //if right tree is empty, simply re-wiring to *node to point to left child
        //note dereference node (*node) gives the address of node, so what we need
        //to do here is populate the value of *node to the left node
        q = *node; //q caches which node is originally pointed
        *node = (*node)->lchild; //re-wiring
        free(q); //q is now wild pointer, delete it
    }
    else if( (*node)->lchild == NULL )
    {
        //if left tree is empty
        q = *node;
        *node = (*node)->rchild;
        free(q);
    }
    else
    {
        //things going to complicated, now both child exists
        //we found the largest node on the left tree
        //the node must not have a right child otherwise it 
        //won't be the largest
        BSTree s;
        s = (*node)->lchild;
        q = *node;
        while( s->rchild )
        {
            q = s;
            s = s->rchild;
        }
        //s is always the largest node on left tree
        //q is always the parent of s
        //now we not re-wiring node, but just copy the data field
        //from s to node, this avoids polluting lchild/rchild pointers
        (*node)->data = s->data;
        //next step, we delete s
        //but before that we need re-wiring s->lchild to q
        //need consider connect (q->lchild or q->rchild) to s->lchild
        if( q != *node )
        {
            //the while(s->rchild) loops at least once
            //so s is rchild of q
            q->rchild = s->lchild;
        }
        else
        {
            //while loop not run, s=(*node)->lchild and q=*node
            q->lchild = s->lchild;
        }
        free(s);
    }
    return true;
}

//delete key from BST
bool DeleteBST( BSTree* tree, int key )
{
    if( !*tree )
    {
        //this indicates key is not found, simply return
        return false;
    }
    else
    {
        if( key == (*tree)->data )
        {
            //if *tree is the node host key, delete it
            return DeleteNode(tree);
        }
        else if( key < (*tree)->data )
        {
            //we need to search on the left tree
            return DeleteBST( &(*tree)->lchild, key);
        }
        else
        {
            return DeleteBST( &(*tree)->rchild, key);
        }
    }
}

int main()
{
    //building up the BST
    BSTree t = NULL;
    int intarr[] = {1,100,67,48,98,55,12,79,9,36};  
    int length = sizeof(intarr)/sizeof(int);  
    int index = 0;
    for( ; index < length; index++ )
    {
        printf(" %d",  intarr[index] );
        InsertBST( &t, intarr[index]);
    }
    //Search for key 67
    int key = 67;
    printf("\nBST search %d...\n", key);
    BSTree found = NULL;
    int child = 1;
    if( SearchBST( t, NULL, key, &found) )
    {
        printf("Found %d, check value %d\n", key, found->data);
        printf("Check left child ");
        if( found->lchild )
        {
            child = found->lchild->data;
            printf("%d\n", child);
        }
        else
        {
            printf("NULL\n");
        }
        printf("Check right child ");
        if( found->rchild )
        {
            child = found->rchild->data;
            printf("%d\n", child);
        }
        else
        {
            printf("NULL\n");
        }
    }
    else
    {
        printf("%d not found\n", key);
    }
    //delete child
    if( DeleteBST(&t, child) )
    {
        printf("Deleted %d from tree\n", child);
        printf("BST search %d again...\n", key);
        if( SearchBST( t, NULL, key, &found) )
        {
          printf("Found %d, check value %d\n", key, found->data);
          printf("Check left child ");
          if( found->lchild )
          {
            child = found->lchild->data;
            printf("%d\n", child);
          }
          else
          {
            printf("NULL\n");
          }
          printf("Check right child ");
          if( found->rchild )
          {
            child = found->rchild->data;
            printf("%d\n", child);
          }
          else
          {
            printf("NULL\n");
          }
        }
        else
        {
            printf("%d not found\n", key);
        }
    }
    else
    {
        printf("Delete %d failed\n", key);
    }   
    printf("\n");
    return 0;
}