数据结构初阶——链式二叉树_链式二叉树的遍历孩子链式存储下树上的基本运算算法和求树t的高度

目录

树概念及结构

树的概念

树的表示

二叉树概念及结构

概念

特殊二叉树

二叉树的性质

二叉树链式结构及实现

二叉树的简单创建

二叉树的前序遍历 

二叉树中序遍历与二叉树后序遍历

求二叉树节点个数

求二叉树叶子节点的个数 

求二叉树的高度 

求二叉树第k层节点个数

二叉树查找值为x的节点

二叉树的层序遍历

判断二叉树是否是完全二叉树

单独取出树的每一层数值

树概念及结构

树的概念

树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。

• 有一个特殊的结点，称为根结点，根节点没有前驱结点
• 除根节点外，其余结点被分成M(M>0)个互不相交的集合T1、T2、……、Tm，其中每一个集合Ti(1<= i<= m)又是一棵结构与树类似的子树。每棵子树的根结点有且只有一个前驱，可以有0个或多个后继
• 因此，树是递归定义的。

注意：在树形结构中，子树之间不能有交集，否则就不是树形结构

一些重要的概念：

节点的度：一个节点含有子树的个数；如上图A的度为6；

叶节点或终端节点：度为零的节点；

非终端节点或分支节点：度不为零的节点；

双亲结点或父节点：若一个节点含有子节点，则这个节点称为其子节点的父节点；

孩子节点或子节点：一个节点含有子树的根节点称为该节点的子节点；

兄弟节点：具有相同父节点的节点互称为兄弟节点；

树的度：一棵树中，最大的节点的度；

节点的层次：从根开始定义，更为第一层，根的子节点为第二层，以此类推；

树的深度：树节点的最大层次；

堂兄弟节点：双亲在同一层的节点互为堂兄弟；

节点的祖先：从根到该节点所经分支上的所有节点；

子孙：以某节点为根的子树中任一节点都称为该节点的子孙；；

森林：由m（m>0）棵互不相交的树的集合称为森林；

树的表示

树结构相对线性表就比较复杂了，要存储表示起来就比较麻烦了，既然保存值域，也要保存结点和结点之间的关系，实际中树有很多种表示方式如：双亲表示法，孩子表示法、孩子双亲表示法以及孩子兄弟表示法等。我们这里就简单的了解其中最常用的孩子兄弟表示法。

typedef int DataType;
struct Node
{
struct Node* _firstChild1; // 第一个孩子结点
struct Node* _pNextBrother; // 指向其下一个兄弟结点
DataType _data; // 结点中的数据域
};

二叉树概念及结构

概念

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

从上图中可以看出：

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

特殊二叉树

1. 满二叉树：一个二叉树，如果每一个层的结点数都达到最大值，则这个二叉树就是满二叉树。也就是说，如果一个二叉树的层数为K，且结点总数是 ，则它就是满二叉树。
2. 完全二叉树：完全二叉树是效率很高的数据结构，完全二叉树是由满二叉树而引出来的。对于深度为K的，有n个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点一一对应时称之为完全二叉树。 要注意的是满二叉树是一种特殊的完全二叉树。

二叉树的性质

1. 若规定根节点的层数为1，则一棵非空二叉树的第i层上最多有 个结点.
2. 若规定根节点的层数为1，则深度为h的二叉树的最大结点数是 .
3. 对任何一棵二叉树, 如果度为0其叶结点个数为 , 度为2的分支结点个数为 ,则有 ＝ ＋1
4. 若规定根节点的层数为1，具有n个结点的满二叉树的深度，h= . (ps： 是log以2为底，n+1为对数)
5. 对于具有n个结点的完全二叉树，如果按照从上至下从左至右的数组顺序对所有节点从0开始编号，则对于序号为i的结点有：
        1. 若i>0，i位置节点的双亲序号：(i-1)/2；i=0，i为根节点编号，无双亲节点
        2. 若2i+1<n，左孩子序号：2i+1，2i+1>=n否则无左孩子
        3. 若2i+2<n，右孩子序号：2i+2，2i+2>=n否则无右孩子

二叉树链式结构及实现

在这里，我们简单地讲述二叉树的一些基本的操作，例如遍历，节点相关等操作。

二叉树的简单创建

这里的代码是二叉树简单地创建，不是真正的创建方式，为了更好地测试二叉树相关的代码。

//二叉树的节点结构
typedef int BTDataType;
 
typedef struct BinaryTreeNode
{
	BTDataType _data;
	struct BinaryTreeNode* _left;
	struct BinaryTreeNode* _right;
}BTNode;
 
二叉树的节点生成
BTNode* ByTreeNode(BTDataType x)
{
	BTNode* newnode = (BTNode*)malloc(sizeof(BTNode));
	if (newnode == NULL)
	{
		perror("malloc failed");
		exit(-1);
	}
	newnode->_left = NULL;
	newnode->_right = NULL;
	newnode->_data = x;
	return newnode;
}
 
 
//生成一颗树
BTNode* BinaryTreeCreate()
{
	BTNode* n1 = ByTreeNode(1);
	BTNode* n2 = ByTreeNode(2);
	BTNode* n3 = ByTreeNode(3);
	BTNode* n4 = ByTreeNode(4);
	BTNode* n5 = ByTreeNode(5);
	BTNode* n6 = ByTreeNode(6);
	//BTNode* n7 = ByTreeNode(7);
 
	n1->_left = n2;
	n1->_right = n4;
	n2->_left = n3;
	n4->_left = n5;
	n4->_right = n6;
	//n2->_right = n7;
 
	return n1;
}

最后生成的就是上图中的树。

二叉树的前序遍历 

前序遍历的顺序是：根、左子树、右子树。

// 二叉树前序遍历 
void PrevOrder(BTNode* root)
{
	if (root == NULL)
	{
		printf("NULL ");
		return;
	}
	//根节点
	printf("%d ", root->_data);
	//递归遍历左节点
	PrevOrder(root->_left);
	//递归遍历右节点
	PrevOrder(root->_right);
}

前序遍历的二叉树的递归展开图：

从上图中我们可以看出，以左子树为例子，从根节点即“1”开始，然后递归进入左子树输出“2”，再递归进入左子树输出“4”，再递归进入左子树，节点等于NULL返回上一层函数帧栈，递归进入右子树，节点为NULL再次返回上一打印值为4的函数帧栈，至此“4”位置的函数全部走完，返回上一层的函数帧栈。递归即进入其右子树。然后依次重复之前的过程直至返回初始的函数帧栈处。我们就可以得到打印出来的前序遍历：1 2 3 NULL NULL 7 NULL NULL 4 5 NULL NULL 6 NULL NULL。

二叉树中序遍历与二叉树后序遍历

这两种遍历方式与前序相类似，区别就是中序遍历的顺序是：左子树、根、右子树；而后序遍历的顺序是：左子树、根、右子树。只需要将打印根节点的指令放在不同的位置，即可获得不同的遍历结果。

// 二叉树中序遍历
void InOrder(BTNode* root)
{
	if (root == NULL)
	{
		printf("NULL ");
		return;
	}
 
	//递归遍历左节点
	InOrder(root->_left);
 
	//根节点
	printf("%d ", root->_data);
 
	//递归遍历右节点
	InOrder(root->_right);
}
 
// 二叉树后序遍历
void PostOrder(BTNode* root)
{
	if (root == NULL)
	{
		printf("NULL ");
		return;
	}
 
	//递归遍历左节点
	PostOrder(root->_left);
 
	//递归遍历右节点
	PostOrder(root->_right);
 
	//根节点
	printf("%d ", root->_data);
}

中序遍历结果：NULL 3 NULL 2 NULL 7 NULL 1 NULL 5 NULL 4 NULL 6 NULL

后续遍历结果：NULL NULL 3 NULL NULL 7 2 NULL NULL 5 NULL NULL 6 4 1

求二叉树节点个数

对于这个问题我们同样可以使用递归的方式进行处理：我们需要求解一棵二叉树的节点个数，将这个问题进行分解，以上述的例子来看，需要求跟节点“1”的节点个数，就是要求解其左子树和右子树的节点个数；要求其左子树的节点，就要以左子树的节点“2”为根节点，求其左子树和右子树的节点个数；直至节点为NULL。

// 求二叉树节点个数
int TreeSize(BTNode* root)
{
	if (root == NULL)
	{
		return 0;
	}
 
	return TreeSize(root->_left) + TreeSize(root->_right) + 1;
}

同样，使用上面的那一棵树，以左子树为例子进行递归展开图的演示：当遇到NULL结点时返回值“0”，当左右子树都为NULL时返回，左子树的节点个数+右节点的子树个数+1（自己本身的节点）。 

求二叉树叶子节点的个数 

这个问题与上述的求节点总个数的问题相类似，当 一个节点的左节点与右节点都为NULL时返回“1”

// 二叉树叶子节点个数
int TreeLeafSize(BTNode* root)
{
	if (root == NULL)
	{
		return 0;
	}
 
	if (root->_left == NULL && root->_right == NULL)
	{
		return 1;
	}
	
	return TreeLeafSize(root->_left) + TreeLeafSize(root->_right);
}

下面是这个问题的左子树递归展开图： 

求二叉树的高度 

//求二叉树的高度
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;
}

在这段程序中我们需要注意的就是，在这里函数帧栈的返回值不能使用如下的形式：    

return TreeHeight(root->_left) > TreeHeight(root->_right) ? TreeHeight(root->_left) + 1 : TreeHeight(root->_right) + 1;

这样的话，当已经递归求解出了左子树的高度，但是数据没有进行保存，在右面需要再一次的进行同样的左子树高度的求解，会造成递归次数过多，导致栈的溢出，因此我们需要及时将子树的高度这个数据进行保存。

递归展开图：

求二叉树第k层节点个数

在求解这个问题的时候同样我们也必须使用递归的思想：要求解第k层的节点个数（相对于第一层），就是求解第k-1层的节点个数（相对于第二层），直到k等于1。分别求解左子树和右子树。

左子树的递归展开图如下： 

二叉树查找值为x的节点

// 二叉树查找值为x的节点
BTNode* TreeFind(BTNode* root, BTDataType x)
{
	if (root == NULL)
	{
		return NULL;
	}
	if (root->_data == x)
	{
		return root;
	}
	BTNode* ret1 = TreeFind(root->_left, x);
	if (ret1 != NULL)
	{
		return ret1;
	}
	BTNode* ret2 = TreeFind(root->_right, x);
	if (ret2 != NULL)
	{
		return ret2;
	}
	return NULL;
}

查找节点的问题与上面的一些问题都类似，及使用递归的方法来进行处理。

二叉树的层序遍历

层序遍历需要我们使用队列来进行处理。

将第一层如队列，当第一层出队列的时候，将其左子树与右子树入队列；再将“2”出队列，同时带入其左子树与右子树。重复上述过程，直至队列为空。

// 层序遍历
void TreeLevelOrder(BTNode* root)
{
	Queue q;
	QueueInit(&q);
	if (root != NULL)
	{
		QueuePush(&q, root);
	}
	while (!QueueEmpty(&q))
	{
		BTNode* front = QueueFront(&q);
 
		printf("%d ", front->_data);
		
		QueuePop(&q);
 
		if (front->_left != NULL)
		{
			QueuePush(&q, front->_left);
		}
		if (front->_right != NULL)
		{
			QueuePush(&q, front->_right);
		}
	}
	printf("\n");
	QueueDestroy(&q);
}

判断二叉树是否是完全二叉树

我们可以利用层序遍历的方法来判断是否为完全二叉树。

完全二叉树的特点：最后一层要是满的或者从左至右依次右节点，不能如下图一样。下图就不是完全二叉树。

​​​​​​​

// 判断二叉树是否是完全二叉树
bool TreeComplete(BTNode* root)
{
	Queue q;
	QueueInit(&q);
	QueuePush(&q, root);
 
	while (!QueueEmpty(&q))
	{
		if (QueueFront(&q) == NULL)
		{
			break;
		}
		BTNode* front = QueueFront(&q);
		QueuePop(&q);
		QueuePush(&q, front->_left);
		QueuePush(&q, front->_right);
	}
 
	while (!QueueEmpty(&q))
	{
		BTNode* tmp = QueueFront(&q);
		if (tmp != NULL)
		{
			QueueDestroy(&q);
			return false;
		}
		QueuePop(&q);
	}
 
	QueueDestroy(&q);
 
	return true;
}

单独取出树的每一层数值

//单独取出树的每一层数值
void TreeLevelNum(BTNode* root)
{
	int TreeLevel = 0;
	Queue q;
	QueueInit(&q);
	QueuePush(&q, root);
	TreeLevel = 1;
 
	while (!QueueEmpty(&q))
	{
		while (TreeLevel--)
		{
			BTNode* front = QueueFront(&q);
			printf("%d ", front->_data);
			QueuePop(&q);
			if (front->_left != NULL)
			{
				QueuePush(&q, front->_left);
			}
 
			if (front->_right != NULL)
			{
				QueuePush(&q, front->_right);
			}
		}
		printf("\n");
 
		//上层出完了下一层进队列
		TreeLevel = QueueSize(&q);
	}
	QueueDestroy(&q);
}