静态数组实现的二叉搜索树

/*_############################################################################
  _##
  _##  静态数组实现的二叉搜索树
  _##  Author: xwlee                        
  _##  Time: 2007.01.01 
  _##  Chang'an University
  _##  Development condition: win2003 Server+VC6.0
  _##
  _##  staticarray_bsearchtree.cpp 文件
  _##########################################################################*/
#include "stack.h"
#include <stdlib.h>
#include <stdio.h>

#define TREE_SIZE 100  // 树的元素个数
#define ARRAY_SIZE ( TREE_SIZE + 1 ) // 第一个元素不用

static TREE_TYPE tree[ ARRAY_SIZE ]; // 用于存储树中所有节点的数组

// left_child
// 计算一个节点左孩子的下标
static int left_child( int current )
{
    return current * 2;
}

// right_child
// 计算一个节点右孩子的下标
static int right_child( int current )
{
    return current * 2 + 1;
}

// insert
void insert( TREE_TYPE value)
{
    int current;
   
    if( value == 0 )
    {
        printf("You can not insert 0.");
        exit(0);
    }

    current = 1; // 从根节点开始.

    // 找到一个合适的位置
    while( tree[ current ] != 0 )
    {
        if( value < tree[ current ] )
            current = left_child( current );
        else
        {
            if( value == tree[ current ] )  // 处理插入相同元素的情况.
            {
                printf("You can not equal data insert./n");
                exit(0);
            }
            current = right_child( current );
        }
       
        if( current >= ARRAY_SIZE )
        {
            printf("Out of array,please try again./n");
            exit(0);
        }
    } // end while

    tree[ current ] = value;
}

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

    // 从根节点开始，直到找到那个值，进入合适的子树.
    current = 1;
    while( current < ARRAY_SIZE && tree[ current ] != value )
    {
        if( value < tree[ current ] )
            current = left_child( current );
        else
            current = right_child( current );
    }

    if( current < ARRAY_SIZE )
        return tree + current;
    else
        return 0;
}

// do_pre_order_traverse
// 执行一次前序遍历，这个帮助函数用于保存我们当前正在处理的节点的信息
// 它并不是用户接口的一部分
static void do_pre_order_traverse( int current, void (*callback)( TREE_TYPE value) )
{
    if( current < ARRAY_SIZE && tree[ current ] != 0)
    {
        callback( tree[ current ] );
        do_pre_order_traverse( left_child(current), callback);
        do_pre_order_traverse( right_child(current), callback);
    }
}

// do_mid_order_traverse
// 执行一次中序遍历，这个帮助函数用于保存我们当前正在处理的节点的信息
// 它并不是用户接口的一部分
static void do_mid_order_traverse( int current, void (*callback)( TREE_TYPE value) )
{
    if( current < ARRAY_SIZE && tree[ current ] != 0)
    {
        do_mid_order_traverse( left_child(current), callback);
        callback( tree[ current ] );
        do_mid_order_traverse( right_child(current), callback);
    }
}

// do_back_order_traverse
// 执行一次后序遍历，这个帮助函数用于保存我们当前正在处理的节点的信息
// 它并不是用户接口的一部分
static void do_back_order_traverse( int current, void (*callback)( TREE_TYPE value) )
{
    if( current < ARRAY_SIZE && tree[ current ] != 0)
    {
        do_back_order_traverse( left_child(current), callback);
        do_back_order_traverse( right_child(current), callback);
        callback( tree[ current ] );
    }
}

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

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

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


// 临时函数
void treeprint()
{
    int i;

    for( i = 1; i< ARRAY_SIZE + 1; i++)
    {
        printf("tree[%d]= %d    ", i, tree[ i ]);
        if( i % 5 == 0 )
            printf("/n");
   
    }
       

}