二叉树的链式实现（插入，查找，遍历，删除）

实现代码：

#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;

}

运行结果：

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