数据结构之树（附带二叉树的存储及遍历C语言实现代码）

树形结构是一种很重要的非线性存储结构，其中以树和二叉树最为常见，本篇文章主要讲解二叉树的存储结构以及各种操作，并研究树和森林与二叉树的转换关系。

1.二叉树

二叉树的特点是每个节点至多只有两颗字数（即二叉树不存在度大于2的节点），并且二叉树的字数有左右之分，次序不能颠倒
二叉树的性质：

1.在二叉树的第i层至多有 $2^{n-1}$个节点

2.深度为k的二叉树至多有 $2^k-1$个节点

3.对于任何一颗二叉树T，如果其终端节点数为n₀，度为2的节点数为n₂,则n₀=n₂+1

二叉树的遍历规则：
先序遍历：先访问根节点，先序遍历左子树，先序遍历右字数
中序遍历：中序遍历左子树，访问根节点，中序遍历右子树
后续遍历：后续遍历左子树，后续遍历右子树，访问根节点

二叉树的存储结构及各种操作代码：

#include <cstdio>
#include <cstdlib>
#define STACK_INIT_SIZE 100
#define STACKINCREASE 10

typedef char ElemType;

//二叉树节点定义
typedef struct BiTNode
{
	ElemType data;
	struct BiTNode *lchild, *rchild;
}BiTNode, *BiTree;

//创建一颗二叉树,前序遍历的方式输入数据
int CreateBiTree(BiTree *T) 
{
	char c;
	scanf("%c", &c);
	if (' ' == c) {
		*T = NULL;	
	}
	else {
		*T = (BiTNode *)malloc(sizeof(BiTNode));	
		(*T)->data = c;
		CreateBiTree(&(*T)->lchild);
		CreateBiTree(&(*T)->rchild);
	}
	return 0;
}
//打印节点
int visit(char c)
{
	printf("%c ", c);
	return 0;
}

//前序遍历二叉树(递归实现)
void PreOrderTraverse(BiTree T)
{
	if (T) {
		visit(T->data);
		PreOrderTraverse(T->lchild);
		PreOrderTraverse(T->rchild);
	}
}

//中序遍历二叉树(递归)
void InOrderTraverse(BiTree T) 
{
	if (T != NULL) {
		InOrderTraverse(T->lchild);
		visit(T->data);
		InOrderTraverse(T->rchild);
	}
}

//后序遍历二叉树(递归)
void PostOrderTraverse(BiTree T) 
{
	if (T != NULL) {
		PostOrderTraverse(T->lchild);
		PostOrderTraverse(T->rchild);
		visit(T->data);
	}
}

//获取树的深度
int GetDepth(BiTree T) 
{
	if(T == NULL) {
		return 0;	
	} else {
		int m = GetDepth(T->lchild);	
		int n = GetDepth(T->rchild);
		if (m > n) {
			return m + 1;	
		}
		else {
			return n + 1;	
		}
	}	
}

//获取二叉树的叶子节点数
int CountLeaf(BiTree T, int count) {
	if (T) {
		if (T->lchild == NULL && T->rchild ==NULL) {
			count++;
		}	
		count = CountLeaf(T->lchild, count);
		count = CountLeaf(T->rchild, count);
	}
	return count;
}

//获取二叉树的总节点数
int CountNode(BiTree T, int count) {
	if (T) {
		count++;
		count = CountNode(T->lchild, count);
		count = CountNode(T->rchild, count);
	}
	return count;
}

int main(){
	int depth, leafcount = 0, nodecount = 0;
	BiTree T = NULL;
	CreateBiTree(&T);
	PreOrderTraverse(T);
	printf("\n");
	InOrderTraverse(T);
	printf("\n");
	PostOrderTraverse(T);
	printf("\n");
	depth = GetDepth(T);
	printf("%d\n", depth);
	leafcount = CountLeaf(T, leafcount);
	printf("二叉树叶子数:%d\n", leafcount);
	nodecount = CountNode(T, nodecount);
	printf("二叉树的节点数:%d\n", nodecount);
	return 0;	
}

2.树

树的存储结构

1.双亲表示法

#define MAX_TREE_SIZE 100
//双亲表示法
typedef int ElemType;
typedef struct PTNode
{
	ElemType data;  //节点数据
	int parent;		//双亲位置	
}PTNode;
typedef struct 
{
	PTNode nodes[MAX_TREE_SIZE];
	int r;  //根的位置
	int n;	//节点数目
}PTree;

2.孩子表示法

#define MAX_TREE_SIZE 100

typedef char ElemType;
//孩子节点
typedef struct CTNode
{
	int child;   //孩子节点的下标
	struct CTNode *next;  //指向下一个孩子节点的指针
}*ChildPtr;

typedef struct 
{
	ElemType data;		
	ChildPtr firstchild; //孩子链表头指针
}CtBox;

typedef struct 
{
	CTBox nodes[MAX_TREE_SIZE];
	int n; //节点数
	int r;//根位置
}

3.孩子兄弟表示法

typedef struct CSNode {
	ElemType data;
	struct CSNode *firstchild, *nextsibling;
}CSNode, *CSTree;

3.二叉树与树、森林的转换

1.二叉树到树、森林的转化

若节点x是其双亲y的左孩子，则把x的右孩子以及右孩子的右孩子。。。，都与y用连线连起来，然后去掉所有双亲到右孩子的连线

2.树转化为二叉树

在树中所有兄弟节点之间加一连线，然后对于每个节点，除了保留与其的长子的连线外，去掉该节点与其他孩子的连线

3.森林转换为二叉树

在森林中将所有“兄弟节点”之间加一连线，然后对于每个节点，除了保留与其长子的连线外，去掉该节点与其他孩子的连线

规律
1.判断一个二叉树是否是转换为二叉树还是森林，关键看这棵二叉树的根节点是否有右孩子，如果有右孩子则是森林，没有则是一棵树
2.树的遍历分为先根遍历与后根遍历，森林的遍历分为先序遍历和后序遍历，树和森林的前根（序）遍历和二叉树的前序遍历结果相同，树和森林的后根（序）遍历与二叉树的中序遍历结果相同

4.赫尔曼树

树的带权路径长度为树中所有叶子结点的带权路径长度之和，通常记作WPL
WPL最小的二叉树称作最优二叉树或赫尔曼树