实现代码： #define  TREE_TYPE int #include  <stdlib.h> #include <stdio.h> #include <malloc.h> #include <assert.h>

//节点定义 typedef struct TREE_NODE{
TREE_TYPE value;            //节点值
struct TREE_NODE *left; //左孩子
struct TREE_NODE *right; //右孩子 }TreeNode;

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

//插入 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;
}
}
current = (TreeNode *)malloc(sizeof(TreeNode));
assert(current != NULL);
current->value = value;
current->left = NULL;
current->right = NULL;
*link = current; }

//查找 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;
} }

//前序遍历 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);
//callback(current->value); //中序
do_pre_order_traverse(current->right,callback);
//callback(current->value); //后序
} }

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

void Get_pre_order(TREE_TYPE value) {
printf(“%d\n”,value); }

//释放链表树的内存,应采取后序遍历,来防止某一节点的丢失 static void do_back_order_destroy(TreeNode **current,void(*callback)(TreeNode **Nowcurrent)) {
if (*current != NULL)
{
do_back_order_destroy(&((*current)->left),callback);
do_back_order_destroy(&((*current)->right),callback);
callback(current); //后序
} }

void back_order_destroy(void(*callback)(TreeNode **current)) {
do_back_order_destroy(&tree,callback); }

//删除节点,释放节点的内存 void delete_Node(TreeNode **current) {
assert(*current != NULL);
free(*current);
*current = NULL; }

int main() {
insert(12);
insert(5);
insert(9);
insert(2);
insert(17);
insert(19);
insert(14);
insert(15);
printf(“*******************\n”);
pre_order_traverse(Get_pre_order);

back_order_destroy(delete_Node);
if (tree == NULL) //检测树是否为空
{
printf(“Tree Has Been Destroyed!\n”);
}
system(“pause”);
return 0; } 运行结果：

利用链式结构来实现二叉查找树是常用的方法。在删除树时为了使删除后指向根节点的指针为空，do_back_order_destroy(TreeNode **current,void(*callback)(TreeNode **Nowcurrent))函数传入的第一个实参是指向指针的指针。这么做是由于在C语言中只有“传值调用”，注意指针形参传入的是指针值的一份拷贝，在多数函数中只是对指针指向的值进行了处理，而没有对指针的值进行处理。如果为do_back_order_destroy(TreeNode *current,void(*callback)(TreeNode *Nowcurrent))，则传入的实际为tree的一份拷贝，这样在进行内存释放时，回调函数delete_Node(TreeNode *current)只是释放了指针tree所指向的内存，而没有把指针tree的值置为NULL。 关于传值调用传入的指针值的问题，下面还有一个实例说明。 代码： #include  <stdlib.h> #include <stdio.h> #include <malloc.h> #include <assert.h>

void delete_pint(int **p) {
assert(p != NULL);
free(*p);
*p = NULL; }

void delete_int(int *p) {
assert(p != NULL);
free(p);
p = NULL; }

int main() {
int *p_i = (int *)malloc(sizeof(int));
*p_i = 20;
delete_pint(&p_i);
if(p_i == NULL)
{
printf(“p_i == NULL\n”);
}
else
{
printf(“p_i != NULL\n”);
}
p_i = (int *)malloc(sizeof(int));
*p_i = 20;
delete_int(p_i);
if(p_i == NULL)
{
printf(“p_i == NULL\n”);
}
else
{
printf(“p_i != NULL\n”);
}
system(“pause”);
return 0; } 运行结果：

利用这种方法可以在内存释放时将传入指针的值也置为安全状态。