二叉树 ★★★ #数据结构与算法（7）

现实中的树都是根在下面，而计算机中的树都是根在上面！！！

也就是。。。这样：

其中 ① ② ③ ④ ⑤ 。。。都是节点【表示的是集合】， ->是边【表示的是关系】，其中 ① 是根节点【表示全集】，而 ② ③ ④ 等 是子节点【是根节点的子集】，最下面的节点也可以是叶子节点【我们把它们理解成树叶】。

其实我们也可以从上图看出：②∪③∪④得到 ① 的全集，并且② ③ ④没有任何交集存在。

怎么判断这个树是几叉树？要求我们要看边最多的节点，这个节点有几个边就是几叉树。

高度是什么？要求从根节点开始到最长的叶子节点个数就是这棵树的高度。

高度 != 深度 ？ 可以这么说。如果我们要从子节点来看的话， 例如：④的高度是4，它的深度是2。

高度？就是从当前位置去树叶去看。

深度？从当前位置向根部去看。

度是啥？度分为出度和入度 。例如：每个节点的度最多为三的就叫作三叉树。这里节点⑥的度为0。

为啥二叉树如此重要呢？我们刚上来为啥不学习三叉树，四叉树，五叉树，偏偏学习二叉树？

其实这和二进制有关系，我们都知道计算机的最开始的传输信号就两个，一个低频，一个高频，我们用二进制中的0和1表示了这两个信号，而二进制是可以储存任何数字的，进而可以储存任何信息。如果大家把这两个联系到一起就不陌生了吧，知道为啥二叉树这么重要了吧！！！

★ 度为零的节点比度为2的节点多一个。怎么理解这句话呢？换句话说，怎么证明这句话是正确的呢？

通过上面我们知道：节点的数量等于边数+1。

我们分别用 n0（度为0的节点个数），n1（度为1的节点个数），n2（度为2的节点个数），所以总节点个数为n0+n1+n2,所以经推算可以是0+n0+n1+2n2+1,所以n0+n1+n2=0+n1+2n2+1,则：n0=n2+1。

二叉树的遍历：

①.前序遍历【1.根 2.左 3.右】如上图所例，则排序为：1，2，4，5，3，6 。

②.中序遍历【1.左 2.根 3.右】如上图所例，则排序为：4，2，5，1，3，6 。

③.后序遍历【1.左 2.右 3.根】如上图所例，则排序为：4，5，2，6，3，1 。

再举个例子：

前序遍历是：1，2，3，5，6，7 。

中序遍历是：3，2，6，7，5，1 。

后序遍历是：3，7，6，5，2，1 。 【至于为什么？按照前面的说法自己体会吧！！！】

还有就是几叉树转二叉树的方法？

★左孩子，右兄弟法！！！【又叫 十字链表示法】

根节点是从1开始编号的，通过编号可以知道谁是谁的孩子，谁是谁的父亲？

其实有一种数型结构：二叉排序树（又叫作 二叉查找树）=》其实本质上都是二叉树。

下面进行代码演示和解析：

1. 头文件包含：

#include <stdio.h>

#include <stdlib.h>

包含了标准输入输出头文件和动态分配内存头文件。

2. 定义结构体：

typedef struct Node {

int data;

struct Node *lchild,*rchild;

}Node;



typedef struct BS_Tree {

Node *root;

int length;

}BS_Tree;

定义了二叉树的节点结构体和二叉搜索树结构体。节点结构体包含了数据和左右子节点指针，二叉搜索树结构体包含了根节点指针和树的长度。

3. 新建节点函数：

Node *getNewNode(int val) {

Node *p = (Node *)malloc(sizeof(Node));

p->data = val;

p->lchild = NULL;

p->rchild = NULL;

return p;

}

动态分配一个节点，初始化节点的数据为输入的值，左右子节点指针为空，返回新建节点的指针。

4. 初始化树函数：

BS_Tree *init_tree() {

BS_Tree *t = (BS_Tree *)malloc(sizeof(BS_Tree));

t->root = NULL;

t->length = 0;

return t;

}

动态分配一棵树，初始化根节点为空，树的长度为 0，返回新建树的指针。

5. 释放节点函数：

void clear_node(Node *root) {

if(root == NULL) return ;

clear_node(root->lchild);

clear_node(root->rchild);

free(root);

return ;

}

递归释放节点的函数，先释放左右子节点，在释放节点本身。

6. 释放树函数：

void clear(BS_Tree *t) {

if(t == NULL) return ;

clear_node(t->root);

free(t);

return ;

}

释放整棵树的函数，释放根节点和整个节点的内存。

7. 插入节点函数：

Node *insert_node(Node *root, int val, int *flag) {

if (root == NULL) {

root = getNewNode(val);

*flag = 1;

return root;

}

if(val < root->data) root->lchild = insert_node(root->lchild, val, flag);

else if (val > root->data) root->rchild = insert_node(root->rchild, val, flag);

return root;

}

递归插入节点的函数，按照二叉搜索树的性质，小的值插入到左子树，大的值插入到右子树。如果节点为 NULL，新建节点并返回，同时 flag 为 1 表示新插入了一个节点，树的长度加 1。

8. 插入函数：

int insert(BS_Tree *t, int val) {

if(t == NULL) return 0;

int flag = 0;

t->root = insert_node(t->root, val, &flag);

t->length += flag;

return flag;

}

插入节点的接口函数，flag 表示是否插入了新的节点，插入成功返回插入节点时的 flag 值。

9. 先序遍历函数：

void pre_order_node(Node *root) {

if (root == NULL) return ;

printf("%d", root->data);

pre_order_node(root->lchild);

pre_order_node(root->rchild);

return ;

}



void pre_order(BS_Tree *t) {

if(t == NULL) return ;

printf("pre_order (%d):",t->length);

pre_order_node(t->root);

printf("\n");

return ;

}

先序遍历的递归函数和接口函数，先输出当前节点的值，再输出左子节点和右子节点的值。

10. 中序遍历函数：

void in_order_node(Node *root) {

if (root == NULL) return ;

in_order_node(root->lchild);

printf("%d ", root->data);

in_order_node(root->rchild);

}



void in_order(BS_Tree *t) {

if (t == NULL) return ;

printf("in_order (%d): ", t->length);

in_order_node(t->root);

printf("\n");

return ;

}

中序遍历的递归函数和接口函数，先输出左子节点的值，再输出当前节点的值，最后输出右子节点的值。

11. 后序遍历函数：

void post_order_node(Node *root) {

if (root == NULL) return ;

post_order_node(root->lchild);

post_order_node(root->rchild);

}



void post_order(BS_Tree *t) {

if (t == NULL) return ;

printf("post_order(%d) :",t->length);

post_order_node(t->root);

printf("\n");

return ;

}

后序遍历的递归函数和接口函数，先输出左子节点和右子节点的值，再输出当前节点的值。

12. 输出函数：

void output_node(Node *root) {

if (root == NULL) return ;

printf("%d", root->data);

if (root->lchild == NULL && root->rchild == NULL) return ;

printf("(");

output_node(root->lchild);

printf(",");

output_node(root->rchild);

printf(")");

return ;

}



void output(BS_Tree *t) {

if(t == NULL) return ;

printf("table_string : ");

output_node(t->root);

printf("\n");

return ;

}

输出树的结构的函数，输出当前节点的值，如果左右子节点都为空，返回，否则输出左右子节点指针对应节点的值。

13. 主函数：

int main () {

#define MAX_N 10

BS_Tree *t = init_tree();

int val;

for (int i = 0; i < MAX_N; i++) {

scanf("%d", &val);

insert(t, val);

}

pre_order(t);

in_order(t);

post_order(t);

output(t);

return 0;

}

定义了最大输入数据 MAX_N，新建一棵树，插入输入的数值，分别进行先序、中序、后序遍历和输出树的结构。

#include <stdio.h>
#include <stdlib.h>

typedef struct Node {
	int data;
	struct Node *lchild,*rchild;
}Node;

typedef struct BS_Tree {
	Node *root;
	int length;
}BS_Tree;

Node *getNewNode(int val) {
	Node *p = (Node *)malloc(sizeof(Node));
	p->data = val;
	p->lchild = NULL;
	p->rchild = NULL;
	return p;
}

BS_Tree *init_tree() {
	BS_Tree *t = (BS_Tree *)malloc(sizeof(BS_Tree));
	t->root = NULL;
	t->length = 0;
	return t;
}

void clear_node(Node *root) {
	if(root == NULL) return ;
	clear_node(root->lchild);
	clear_node(root->rchild);
	free(root);
	return ;
}

void clear(BS_Tree *t) {
	if(t == NULL) return ;
	clear_node(t->root);
	free(t);
	return ;
}

Node *insert_node(Node *root, int val, int *flag) {
	if (root == NULL) {
		root = getNewNode(val);
		*flag = 1;
		return root;
	}
	if(val < root->data) root->lchild = insert_node(root->lchild, val, flag);
	else if (val > root->data) root->rchild = insert_node(root->rchild, val, flag);
	return root;
}

int insert(BS_Tree *t, int val) {
	if(t == NULL) return 0;
	int flag = 0;
	t->root = insert_node(t->root, val, &flag);
	t->length += flag;
	return flag;
}

void pre_order_node(Node *root) {
	if (root == NULL) return ;
	printf("%d", root->data);
	pre_order_node(root->lchild);
	pre_order_node(root->rchild);
	return ;
}

void pre_order(BS_Tree *t) {
	if(t == NULL) return ;
	printf("pre_order (%d):",t->length);
	pre_order_node(t->root);
	printf("\n");
	return ;
}

void in_order_node(Node *root) {
	if (root == NULL) return ;
	in_order_node(root->lchild);
	printf("%d ", root->data);
	in_order_node(root->rchild);
}

void in_order(BS_Tree *t) {
	if (t == NULL) return ;
	printf("in_order (%d): ", t->length);
	in_order_node(t->root);
	printf("\n");
	return ;
}

void post_order_node(Node *root) {
	if (root == NULL) return ;
	post_order_node(root->lchild);
	post_order_node(root->rchild);
}

void post_order(BS_Tree *t) {
	if (t == NULL) return ;
	printf("post_order(%d) :",t->length);
	post_order_node(t->root);
	printf("\n");
	return ;
}

void output_node(Node *root) {
	if (root == NULL) return ;
	printf("%d", root->data);
	if (root->lchild == NULL && root->rchild == NULL) return ;
	printf("(");
	output_node(root->lchild);
	printf(",");
	output_node(root->rchild);
	printf(")");
	return ;
}

void output(BS_Tree *t) {
	if(t == NULL) return ;
	printf("table_string : ");
	output_node(t->root);
	printf("\n");
	return ;
}

int main () {
	#define MAX_N 10
	BS_Tree *t = init_tree();
	int val;
	for (int i = 0; i < MAX_N; i++) {
		scanf("%d", &val);
		insert(t, val);
	}
	pre_order(t);
	in_order(t);
	post_order(t);
	output(t);
	return 0;
} 

【这是总代码！！！】