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

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");

}