二叉搜索树的链表实现（又称排序树、查找树）

list_tree.h:

// 树的元素的类型.

#define TREE_TYPE  int 

typedef struct TREE_NODE{

    TREE_TYPE value;

    struct TREE_NODE *left;

    struct TREE_NODE *right;

}treenode;

 

// --------------------------外部接口-------------------------------

// 向树添加一个新值，参数是需要被添加的值，它必须原先并不存在于树中

void insert( TREE_TYPE value );

 

// 查找一个特定的值，函数返回该值的指针.

TREE_TYPE *find( TREE_TYPE value );

 

// 执行树的前序遍历，它的参数是一个回调函数指针，它所指向的函数将在

// 树中处理每个结点时被调用，结点的值作为参数传递给这个函数.

void pre_order_traverse( void (*callback)(TREE_TYPE value) );

 

// 执行树的中序遍历，它的参数是一个回调函数指针，它所指向的函数将在

// 树中处理每个结点时被调用，结点的值作为参数传递给这个函数.

void mid_order_traverse( void (*callback)(TREE_TYPE value) );

 

// 执行树的后序遍历，它的参数是一个回调函数指针，它所指向的函数将在

// 树中处理每个结点时被调用，结点的值作为参数传递给这个函数.

void back_order_traverse( void (*callback)(TREE_TYPE value) );

 

// --------------------------外部接口-------------------------------

 

// 临时函数

treenode **get_tree_piont( void );

 

list_tree.c:

#include "list_tree.h"

#include <stdio.h>

#include <stdlib.h>

#include <malloc.h>

#include <assert.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

        {

            assert( value != current->value ); // 处理插入相同元素的情况.

            link = &current->right;

        }

    } // end while

 

    // 分配一个新节点，使适当节点的link字段指向它.

    current = (treenode *)malloc( sizeof( treenode) );

 

    assert( current != NULL );

 

    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;

}

 

test.c:

#include "list_tree.h"

#include <stdio.h>

 

void my_callback(TREE_TYPE value)

{

       printf("%d  ", value);

}

 

//中序遍历打印

void treeprint( treenode **p )

{

       treenode **treep;

       treenode *current = *p;

       int i=0;

 

    treep = get_tree_piont();

 

    if( current != NULL)

    {

        treeprint( &current->left);

        printf("%d  /n", current->value);

        treeprint( &current->right);

    }

}

 

void main()

{

       treenode **treep;

    treep = get_tree_piont();

 

       insert(20);

       insert(12);

       insert(25);

       insert(28);

       insert(26);

       insert(29);

       insert(5);

       insert(16);

       insert(9);

       insert(17);

 

       treeprint( treep );

 

       printf("/n先序遍历：");

       pre_order_traverse(my_callback);

 

       printf("/n中序遍历：");

       mid_order_traverse(my_callback);

 

       printf("/n后序遍历：");

       back_order_traverse(my_callback);

 

       printf("/n/n");

}