2020-10-31

二叉树

二叉树的绝大多数操作都可以采用递归的方法来实现
方块类型的变量代表一整颗树，圆圈类型的变量只代表一个节点
有序二叉树： 任何一个树的左子树上都比他的节点的数小，右子树比节点的数大，则为有序二叉树
树的遍历： 依次处理树的每一个节点，需要通过递归来实现
树的遍历一定是先遍历左子树然后遍历右子树
根节点的处理顺序：
在处理子树之前处理根节点， 前序遍历
在两个子树之间处理根节点，中序遍历
处理两个子树之后处理根节点，后续遍历

头文件

#ifndef  __TREE__H
#define  __TREE__H
struct node;  //  注意 不能将两个结构体反过来声明，因为 结构体中有指针，知识占据一个int类型就可以了 
              //  但是stuct node 中含有的是结构体，需要知道结构体中具体含有什么，因此不能通过提前声明来编译通过
typedef struct{
	struct node *p_node;
} tree_t; //  表示方块

typedef struct node {
	int val;
	tree_t left;
	tree_t right;
} node_t;  //  表示圆圈
typedef void (*pfunc_t)(int);
void tree_init(tree_t *p_tree);
void tree_deinit(tree_t *p_tree);

tree_t *tree_serach(const tree_t *p_tree, int val);

int tree_insert(tree_t *p_tree, int val);

void tree_show(const tree_t *p_tree, pfunc_t);
int tree_size(const tree_t *);
int tree_high(const tree_t *);
#endif

c 文件

#include<stdio.h>
#include<stdlib.h>
#include"01_tree.h"
void tree_init(tree_t *p_tree)
{
	p_tree->p_node = NULL;
}
//  树的删除需要一个遍历的过程，因此也是一个递归的操作
// 需要使用后续遍历，先处理左子树，再处理右子树，最后处理根节点
// 递归操作： 1.先将问题分解为可以循环的小问题  2. 找到无法进行下去的条件（出口），做操作
void tree_deinit(tree_t *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;
}

// 插入分为两步 1. 找到插入的位置  2. 执行插入
// 找到出入的位置 操作按照顺序树出入
tree_t *tree_serach(const tree_t *p_tree, int val)
{
	if (!p_tree->p_node)
		return (tree_t *) p_tree;;
	//如果要插入的位置恰好为跟节点
	if(p_tree->p_node->val == val)
		return (tree_t *) p_tree;
	// 如果插入的位置比根节点的值小，则向左子树找
	else if (p_tree->p_node->val > val) {
		 tree_serach(&(p_tree->p_node->left), val);
	}
	else 
	{
		 tree_serach(&(p_tree->p_node->right),val);
	}
} 

int tree_insert(tree_t *p_tree, int val)
{
	tree_t *p_tmp = NULL;  
	node_t *p_node = NULL;
	p_tmp = tree_serach(p_tree, val);
	if (p_tmp->p_node)
		return 0;
	p_node = (node_t *)malloc(sizeof(node_t));
	if(!p_node)
		return 0;
	p_node->val = val;
	p_node->left.p_node = NULL;
	p_node->right.p_node = NULL;
	p_tmp->p_node = p_node;
	return 1;
}

void tree_show(const tree_t *p_tree, pfunc_t p_func )
{
	if (!p_tree->p_node)
		return;
	tree_show(&(p_tree->p_node->left), p_func);
	p_func(p_tree->p_node->val);
	tree_show(&(p_tree->p_node->right),p_func);
}

int tree_size(const tree_t *p_tree)
{
	int size = 0;
	if (!p_tree->p_node)
		return 0;
	size = tree_size(&(p_tree->p_node->left));
	size += tree_size((&p_tree->p_node->right));
	return size + 1;
}
int tree_high(const tree_t *p_tree)
{
	int highle = 0, highrh = 0;
	if (!p_tree->p_node)
		return 0;
	highle = tree_high(&(p_tree->p_node->left));
	highrh = tree_high(&(p_tree->p_node->right));
	return ((highle >= highrh) ? highle : highrh) + 1; 
}

main 文件

#include<stdio.h>
#include"01_tree.h"

void print(int val)
{
	printf("%d ",val);
}

int main()
{
	tree_t  p_tree = {0};
	tree_init(&p_tree);
	tree_insert(&p_tree, 20);
	tree_insert(&p_tree, 30);
	tree_insert(&p_tree, 40);
	tree_insert(&p_tree, 50);
	tree_insert(&p_tree, 60);
	tree_insert(&p_tree, 230);
	tree_insert(&p_tree, 2);
	tree_insert(&p_tree, 170);
    tree_show(&p_tree, print);
	printf("\n");
	printf("size = %d \n",tree_size(&p_tree));
	printf("high = %d \n",tree_high(&p_tree));
	tree_deinit(&p_tree);

}

运行结果：
2 20 30 40 50 60 170 230
size = 8
high = 7