使用动态分配的链式结构实现的二叉搜索树

/*_############################################################################
  _##
  _##  使用动态分配的链式结构实现的二叉搜索树
  _##  Author: xwlee                        
  _##  Time: 2007.01.01 
  _##  Chang'an University
  _##  Development condition: win2003 Server+VC6.0
  _##
  _##  dynamic_bsearchtree.cpp 文件
  _##########################################################################*/
#include "stack.h"
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>

static treenode *tree;  // 指向树根节点的指针.

// insert
void insert( TREE_TYPE value)
{
    treenode *current;
    treenode **link;

    // 从根节点开始.
    link = &tree;
   
    //持续查找值，进入合适的子树
    while( (current = *link) != NULL )
    {  
        // 根据情况，进入左子树或右子树（确认没有出现重复的值）.
        if( value < current->value )
            link = &current->left;
        else
        {
            if( value == current->value )  // 处理插入相同元素的情况.
            {
                printf("You can not equal data insert./n");
                exit(0);
            }
            link = &current->right;
        }
    } // end while

    // 分配一个新节点，使适当节点的link字段指向它.
    current = (treenode *)malloc( sizeof( treenode) );
    if( current == NULL )
    {
        printf("malloc is false./n");
        exit(0);
    }
    current->value = value;
    current->left = NULL;
    current->right = NULL;
    *link = current;
}

// find
TREE_TYPE *find( TREE_TYPE value)
{
    treenode *current;

    // 从根节点开始，直到找到那个值，进入合适的子树.
    current = tree;
    while( current != NULL && current->value != value )
    {
        if( value < current->value )
            current = current->left;
        else
            current = current->right;
    }

    if( current != NULL )
        return &current->value;
    else
        return NULL;
}

// do_pre_order_traverse
// 执行一次前序遍历，这个帮助函数用于保存我们当前正在处理的节点的信息
// 它并不是用户接口的一部分
static void do_pre_order_traverse( treenode *current, void (*callback)( TREE_TYPE value) )
{
    if( current != NULL)
    {
        callback( current->value );
        do_pre_order_traverse( current->left, callback);
        do_pre_order_traverse( current->right, callback);
    }
}

// do_mid_order_traverse
// 执行一次中序遍历，这个帮助函数用于保存我们当前正在处理的节点的信息
// 它并不是用户接口的一部分
static void do_mid_order_traverse( treenode *current, void (*callback)( TREE_TYPE value) )
{
    if( current != NULL)
    {
        do_mid_order_traverse( current->left, callback);
        callback( current->value );
        do_mid_order_traverse( current->right, callback);
    }
}

// do_back_order_traverse
// 执行一次后序遍历，这个帮助函数用于保存我们当前正在处理的节点的信息
// 它并不是用户接口的一部分
static void do_back_order_traverse( treenode *current, void (*callback)( TREE_TYPE value) )
{
    if( current != NULL)
    {
        do_back_order_traverse( current->left, callback);
        do_back_order_traverse( current->right, callback);
        callback( current->value );
    }
}

// pre_order_traverse
void pre_order_traverse( void (*callback)( TREE_TYPE value) )
{
    do_pre_order_traverse( tree, callback );
}

// mid_order_traverse
void mid_order_traverse( void (*callback)( TREE_TYPE value) )
{
    do_mid_order_traverse( tree, callback );
}

// back_order_traverse
void back_order_traverse( void (*callback)( TREE_TYPE value) )
{
    do_back_order_traverse( tree, callback );
}


// 临时函数
treenode **get_tree_piont( void )
{
    return &tree;
}