C语言数据结构——数据结构有序二叉树的函数实现

关于二叉树的几个知识点：

(1)二叉树的实现通常采用递归调用的方法

(2)在遍历二叉树时一定要先处理左子树再处理右子树

(3)二叉树的遍历分成三种方式：前序遍历，中序遍历和后序遍历

前序遍历：最先处理根节点的遍历方式；

中序遍历：中间处理根节点的方式；

后序遍历：最后处理根节点的方式。

(4)有序二叉树：任何节点的左子树上的所有数都比它小，右子树上的所有数都比它大。

(5)本文将二叉树的一个节点分成两个结构体，一个是结构体类型tree，它代表二叉树，其中包含一个成员变量——node结构体类型的指针变量p_node，它代表二叉树根节点的地址（可以用根节点表示二叉树）；另一个是结构体类型node，它代表二叉树的其中一个节点，它包含三个成员变量，分别是整型数和两个分别代表左右两个子树的节点。如下图所示：



1、头文件：

/****************tree.h***************/

#ifndef     __TREE_H__
#define     __TREE_H__
struct node;
typedef struct {
struct node *p_node;
} tree;
typedef struct node {
int num;
tree left;
tree right;
} node;
//树的初始化函数
void tree_init(tree *);
//树的清理函数
void tree_deinit(tree *);
//向有序二叉树里加入数字的函数
void tree_insert_in_order(tree *, int);
//中序遍历函数
void tree_miter(tree *, void (*)(int));
//前序遍历函数
void tree_fiter(tree *, void (*)(int));
//后序遍历函数
void tree_liter(tree *, void (*)(int));
//从有序二叉树里删除某个数字
void tree_remove(tree *, int);
#endif   //__TREE_H__

2、源码：

/***************tree.c******************/
#include <stdlib.h>
#include "tree.h"
//树的初始化函数
void tree_init(tree *p_tree) {
p_tree->p_node = NULL;
}
//树的清理函数
void tree_deinit(tree *p_tree) {
if (!(p_tree->p_node)) {
return ;
}
tree_deinit(&(p_tree->p_node->left));
tree_deinit(&(p_tree->p_node->right));
free(p_tree->p_node);
p_tree->p_node = NULL;
}
//在有序二叉树中查找某个数字应该在的位置
const tree *tree_search_in_order(const tree *p_tree, int num) {
if (!(p_tree->p_node)) {
return p_tree;
}
if (p_tree->p_node->num == num) {
return p_tree;
}
else if (p_tree->p_node->num > num) {
return tree_search_in_order(&(p_tree->p_node->left), num);
}
else {
return tree_search_in_order(&(p_tree->p_node->right), num);
}
}
//向有序二叉树里加入数字的函数
void tree_insert_in_order(tree *p_tree, int num) {
tree *p_tmp = (tree *)tree_search_in_order(p_tree, num);
if (p_tmp->p_node) {
return ;
}
node *p_node = (node *)malloc(sizeof(node));
if (p_node) {
p_node->num = num;
p_node->left.p_node = NULL;
p_node->right.p_node = NULL;
p_tmp->p_node = p_node;
}
}
//中序遍历函数
void tree_miter(tree *p_tree, void (*p_func)(int)) {
if (!(p_tree->p_node)) {
return ;
}
tree_miter(&(p_tree->p_node->left), p_func);
p_func(p_tree->p_node->num);
tree_miter(&(p_tree->p_node->right), p_func);
}
//前序遍历函数
void tree_fiter(tree *p_tree, void (*p_func)(int)) {
if (!(p_tree->p_node)) {
return ;
}
p_func(p_tree->p_node->num);
tree_fiter(&(p_tree->p_node->left), p_func);
tree_fiter(&(p_tree->p_node->right), p_func);
}
//后序遍历函数
void tree_liter(tree *p_tree, void (*p_func)(int)) {
if (!(p_tree->p_node)) {
return ;
}
tree_liter(&(p_tree->p_node->left), p_func);
tree_liter(&(p_tree->p_node->right), p_func);
p_func(p_tree->p_node->num);
}
//从有序二叉树里删除数字的函数
void tree_remove(tree *p_tree, int num) {
tree *p_tmp = (tree *)tree_search_in_order(p_tree, num);
if (!(p_tmp->p_node)) {
return ;
}
node *p_node = p_tmp->p_node;
if (!(p_node->left.p_node)) {
p_tmp->p_node = p_node->right.p_node;
}
else if (!(p_node->right.p_node)) {
p_tmp->p_node = p_node->left.p_node;
}
else {
tree *p_tmp1 = (tree *)tree_search_in_order(&(p_node->left), p_node->right.p_node->num);
p_tmp1->p_node = p_node->right.p_node;
p_tmp->p_node = p_node->left.p_node;
}
free(p_node);
p_node = NULL;
}