数据结构——二叉树链式结构

前言

[1. 二叉树的概念及结构](#1. 二叉树的概念及结构)

1.1概念

[1.2 特殊的二叉树](#1.2 特殊的二叉树)

[1.3 二叉树的性质](#1.3 二叉树的性质)

[1.4 二叉树的存储结构](#1.4 二叉树的存储结构)

[2. 二叉树链式结构实现](#2. 二叉树链式结构实现)

[2.1 手动创建二叉树](#2.1 手动创建二叉树)

[2.2 二叉树的遍历](#2.2 二叉树的遍历)

[2.2.1 前序、中序和后序遍历](#2.2.1 前序、中序和后序遍历)

[2.2.2 层序遍历](#2.2.2 层序遍历)

[2.3 节点个数以及高度](#2.3 节点个数以及高度)

[2.3.1 节点个数](#2.3.1 节点个数)

[2.3.2 求二叉树的高度](#2.3.2 求二叉树的高度)

[2.3.3 第K层的结点个数](#2.3.3 第K层的结点个数)

[2.3.4 查找值为x的结点](#2.3.4 查找值为x的结点)

[2.3.5 二叉树的销毁](#2.3.5 二叉树的销毁)

总结

前言

二叉树的链式结构的实现理解起来比较抽象，涉及到一些递归的问题，这篇文章配备详细的图文解析，希望你有所收获！

1. 二叉树的概念及结构

1.1概念

一棵二叉树是结点的一个有限集合，该集合:或者为空，或者由一个根节点加上两棵别称为左子树和右子树的二叉树组成。

从上图可以看出：

二叉树不存在度大于2的结点
二叉树的子树有左右之分，次序不能颠倒，因此二叉树是有序树

且对于任意的二叉树都是有下面的几种情况合成的：

1.2 特殊的二叉树

满二叉树：一个二叉树，如果每一个层的结点数都达到最大值，则这个二叉树就是满二叉树。也就是说，如果一个二叉树的层数为K，且结点总数是2^k-1，则它就是满二叉树。

完全二叉树：完全二叉树是效率很高的数据结构，完全二叉树是由满二叉树而引出来的。对于深度为K的，有n个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点一一对应时称之为完全二叉树。要注意的是满二叉树是一种特殊的完全二叉树。

1.3 二叉树的性质

若规定根节点的层数为1，则一棵非空二叉树的第i层上最多有2^(i-1)个结点。
若规定根节点的层数为1，则深度为h的二叉树的最大结点数是2^h-1。
对任何一棵二叉树, 如果度为0其叶结点个数为n0 , 度为2的分支结点个数为n2 ,则有n0 ＝n2 ＋1。
若规定根节点的层数为1，具有n个结点的满二叉树的深度，h=log2(n+1)。 (ps：是log以2为底，n+1为对数)。
对于具有n个结点的完全二叉树，如果按照从上至下从左至右的数组顺序对所有节点从0开始编号，则对于序号为i的结点有：

若i>0，i位置节点的双亲序号：(i-1)/2；i=0，i为根节点编号，无双亲节点
若2i+1<n，左孩子序号：2i+1，2i+1>=n否则无左孩子
若2i+2<n，右孩子序号：2i+2，2i+2>=n否则无右孩子

1.4 二叉树的存储结构

二叉树一般可以使用两种结构存储，一种顺序结构，一种链式结构。

1.顺序存储

顺序结构存储就是使用数组来存储，一般使用数组只适合表示完全二叉树 ，因为不是完全二叉树会有空间的浪费。而现实中使用中只有堆才会使用数组来存储。二叉树顺序存储在物理上是一个数组，在逻辑上是一颗二叉树。

下图中，完全二叉树的存储没有浪费数组空间，而非完全二叉树的存储，需要补齐一些树的空间，体现在数组中就是不存储有效值。没有填写有效值，会被系统赋值为随机值，浪费空间极大。

堆的实现和应用 ，在我的上一篇文章有详细解析http://t.csdnimg.cn/pdMkd

2.链式存储

二叉树的链式存储结构是指，用链表来表示一棵二叉树，即用链来指示元素的逻辑关系。通常的方法是链表中每个结点由三个域组成，数据域和左右指针域，左右指针分别用来给出该结点左孩子和右孩子所在的链结点的存储地址。链式结构又分为二叉链和三叉链，现在我们学习一般的都是二叉链。结构示意图如下所示：

cpp 复制代码

    typedef int BTDataType;
    // 二叉链
    struct BinaryTreeNode
    {
        struct BinTreeNode* _pLeft;  // 指向当前节点左孩子
        struct BinTreeNode* _pRight; // 指向当前节点右孩子
        BTDataType _data;            // 当前节点值域
    }

2. 二叉树链式结构实现

2.1 手动创建二叉树

二叉树的创建一般使用递归实现的，但是一开始学习二叉树，我们需要手动创建一个二叉树，再学习二叉树的一些基本操作。这样可以降低学习难度。

数据结构设计上，有一个BTDataType类型的变量来存储数据，还有两个结构体指针，分别这个结点指向左孩子和右孩子。

cpp 复制代码

typedef int BTDataType;

typedef struct BinTreeNode
{
	struct BinTreeNode* left;
	struct BinTreeNode* right;
	BTDataType val;
}BTNode;

BTNode* CreateTree()
{
	BTNode* n1 = BuyNode(1);
	BTNode* n2 = BuyNode(2);
	BTNode* n3 = BuyNode(3);
	BTNode* n4 = BuyNode(4);
	BTNode* n5 = BuyNode(5);
	BTNode* n6 = BuyNode(6);
	
	n1->left = n2;
	n1->right = n4;
	n2->left = n3;
	n4->left = n5;
	n4->right = n6;

	return n1;
}

2.2 二叉树的遍历

2.2.1 前序、中序和后序遍历

学习二叉树的结构，最底层的内容就是遍历。二叉树的遍历是按照某一种特定方式对二叉树的结点进行操作，并且每个结点只操作一次，这个操作与实际的问题相对应。

前序/中序/后序的遍历需要使用递归：

前序遍历(Preorder Traversal 亦称先序遍历)------访问根结点的操作发生在遍历其左右子树之前。
中序遍历(Inorder Traversal)------访问根结点的操作发生在遍历其左右子树之中（间）。
后序遍历(Postorder Traversal)------访问根结点的操作发生在遍历其左右子树之后。

cpp 复制代码

// 二叉树前序遍历
void PreOrder(BTNode* root);
// 二叉树中序遍历
void InOrder(BTNode* root);
// 二叉树后序遍历
void PostOrder(BTNode* root);

前序遍历的示意图如下，需要注意的是，根节点1，已经访问了。

cpp 复制代码

void PreOrder(BTNode* root)
{
	if (root == NULL)
	{
		printf("N ");
		return;
	}
	 
	printf("%d ", root->val);
	PreOrder(root->left);
	PreOrder(root->right);
}

运行该程序后，观察下图，会发现打印结果可以分为根节点-左子树-右子树的方式划分。

中序遍历是先访问左子树再到根，最后访问右子树，代码如下：

cpp 复制代码

void InOrder(BTNode* root)
{
	if (root == NULL)
	{
		printf("N ");
		return;
	}

	InOrder(root->left);
	printf("%d ", root->val);
	InOrder(root->right);
}

运行结果如下，观察下图，会发现打印结果可以分为左子树-根节点-右子树的方式划分。

后序遍历是先访问左子树在访问右子树，最后访问根节点。

cpp 复制代码

void PostOrder(BTNode* root)
{
	if (root == NULL)
	{
		printf("N ");
		return;
	}

	PostOrder(root->left);
	PostOrder(root->right);
	printf("%d ", root->val);
}

运行结果如下，观察下图，会发现打印结果可以分为左子树-右子树-根节点的方式划分。

2.2.2 层序遍历

层序遍历区别于前中后序的递归结构遍历，需要使用队列来循环遍历。设二叉树的根节点所在层数为1，层序遍历就是从所在二叉树的根节点出发，首先访问第一层的树根节点，然后从左到右访问第2层上的节点，接着是第三层的节点，以此类推，自上而下，自左至右逐层访问树的结点的过程就是层序遍历。

cpp 复制代码

typedef struct BinTreeNode* QDataType;
typedef struct QueueNode
{
	struct QueueNode* next;
	QDataType data;
}QueueNode;

// 队列的结构
typedef struct Queue
{
	QueueNode* head;
	QueueNode* tail;
}Queue;

层序遍历需要一个队列，将队列的存储元素类型改变成二叉树链式结点的指针。（如果队列这个数据结构不是很熟，可以看看我之前写的关于队列的文章http://t.csdnimg.cn/awd50）

我们先判断根节点是否为空，不为空就将这个二叉树的根节点压进队列中。
然后定义一个类型为二叉树节点指针的变量front，来接收队列的队头元素，然后将队头元素删除出队列。
再判断根节点左孩子结点是否为空，不为空就将其压进队列中，右孩子结点也是一样的做法。
然后还是用front接收队头元素，再删除队头元素，判断左右孩子是否为空，不为空就压进队列，重复这个操作知道队列中没有元素，为空的时候结束。

cpp 复制代码

void TreeLevelOrder(BTNode* root)
{
	Queue q;
	QueueInit(&q);
	if (root)
		QueuePush(&q, root);

	while (!QueueEmpty(&q))
	{	//获取队头元素
		BTNode* front = QueueFront(&q);
		QueuePop(&q);
		printf("%d ", front->val);

		if (front->left)//左孩子不为空就进队列
			QueuePush(&q, front->left);

		if (front->right)//右孩子不为空就进队列
			QueuePush(&q, front->right);
	}
	printf("\n");

	QueueDestroy(&q);
}

运行结果如下：

2.3 节点个数以及高度

2.3.1 节点个数

求二叉树的结点个数，一般都是用递归实现。使用递归解决一个问题，需要两部

递归的子问题是什么
返回的条件是什么（最小子问题）

求二叉树的结点个数，相当于求根节点的个数 加上左子树的个数 和右子树的个数

返回条件就是当这个根节点为空的时候，返回0。根节点不为空的时候，返回根节点的个数，就是1，再加上左子树和右子树。

下面的代码使用了一个三目操作符，判断root是否为空，为空返回零，不为空返回最小子问题。

cpp 复制代码

int TreeSize(BTNode* root)
{
	return root == NULL ? 0 :
		TreeSize(root->left) + TreeSize(root->right) + 1;
}

运行结果如下：

2.3.2 求二叉树的高度

用递归解决这类问题先要找出子问题

二叉树的高度相当于根的高度(为1)加上左子树高度和右子树高度中较大的那一个。

返回的条件是当递归的根节点为空的时候，返回0。

cpp 复制代码

int TreeHeight(BTNode* root)
{
	if (root == NULL)
		return 0;

	int leftHeight = TreeHeight(root->left);
	int rightHeight = TreeHeight(root->right);

	return leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1;
}

2.3.3 第K层的结点个数

二叉树递归的转化，一般都是以左右子树作为子问题来分解。比如求第三层结点的个数，相当于根节点的左子树2第二层结点个数和右子树4的第二层结点个数。

返回的条件是，遇到根节点为空，返回0，如果根节点不为空，且k等于1，相当于已经达到所求的层数，返回1，其他情况就是需要继续划分为子问题。

cpp 复制代码

int TreeLevelKSize(BTNode* root, int k)
{
	assert(k > 0);
	if (root == NULL)
	{
		return 0;
	}

	if (k == 1)
	{
		return 1;
	}

	return TreeLevelKSize(root->left, k - 1) + TreeLevelKSize(root->right, k - 1);
}

2.3.4 查找值为x的结点

二叉树查找值为x的结点，我们先划分子问题，就是先找根节点，再找左子树和右子树。

返回的条件，

如果递归的根节点为空，就返回空结点。
如果递归的结点不为空且刚好遇到根节点的值为x，就返回该节点。
剩下的就是，递归的根节点既不为空，根节点的值又不为x，就需要定义一个结点，先查找左子树，再判断该返回值是否为空，不为空就返回这个结点。
右子树也是相同的操作。
最后要是都递归完之后，没有返回结点，说明值为x的结点不存在，返回空。

cpp 复制代码

BTNode* TreeFind(BTNode* root, BTDataType x)
{
	if (root == NULL)
		return NULL;

	if (root->val == x)
		return root;

	BTNode* ret1 = TreeFind(root->left, x);
	if (ret1)
		return ret1;

	BTNode* ret2 = TreeFind(root->right, x);
	if (ret2)
		return ret2;

	return NULL;
}

2.3.5 二叉树的销毁

二叉树的销毁一般使用后序遍历的方法进行销毁，前序遍历和中序遍历也可以，但是一旦先释放了根节点，就很难找到左子树或者右子树，需要一个定义一个变量存储起来，十分麻烦。

cpp 复制代码

void TreeDestroy(BTNode* root)
{
	if (root == NULL)
		return;

	TreeDestroy(root->left);
	TreeDestroy(root->right);
	free(root);
}

总结

二叉树的链式结构实现就到这里就告一段落了。二叉树深层次的核心是递归，仅仅是学会这几个实现是远远不够的，还需要再练习一些关于链式二叉树的OJ题目。在下一篇二叉树的文章，会解析一写递归OJ题目。所以链式二叉树的数据结构你掌握了吗？赶紧练起来吧！

创作不易，希望这篇文章能给你带来启发和帮助，如果喜欢这篇文章，请留下你的三连，你的支持的我最大的动力！！！