数据结构——二叉树的遍历与应用

已于 2024-03-05 20:30:39 修改
阅读量1.3k 收藏 30
点赞数 30
文章标签： 数据结构 c语言
于 2024-01-18 20:42:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fax_player/article/details/133499847
版权

fe594ea5bf754ddbb223a54d8fb1e7bc.gif

目录

​一.前言

二. 二叉树链式结构的实现

2.1 前置说明

2.2 二叉树的遍历

2.2.1 前序、中序以及后序遍历

前序遍历：

中序遍历递归图：

后序遍历：

2.3节点个数

2.4叶子节点个数

2.5第K层的节点个数

2.6 二叉树查找值为x的节点

2.7 二叉树的销毁

2.8 层序遍历

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

3.0 全部代码

三.结语

8fb442646f144d8daecdd2b61ec78ecd.png一.前言

大家好久不见，放寒假了咱得还债了，争取这个寒假能把c++篇写一大半！码字不易，希望大家多多支持我呀！（三连＋关注，你是我滴神！）

二. 二叉树链式结构的实现

2.1 前置说明

在学习二叉树的基本操作前，需先要创建一棵二叉树，然后才能学习其相关的基本操作。为了方便大家理解，这里我先采用手动创建一棵简单的二叉树来快速进行操作学习，等二叉树结构完结得差不多我们再来研究二叉树真正的创建方式。

//搭建二叉树结构
typedef struct BinaryTreeNode
{
	struct BinaryTreeNode* left;
	struct BinaryTreeNode* right;
	int val;
}BTNode;

//创造节点
BTNode* BuyNode(int x)
{
	BTNode* node = (BTNode*)malloc(sizeof(BTNode));
	if (node == NULL)
	{
		perror("node faild");
		exit(-1);
	}
	node->val = x;
	node->left = NULL;
	node->right = NULL;
	return node;
}

int main()
{
	//手动构建节点
	BTNode* node1 = BuyNode(1);
	BTNode* node2 = BuyNode(2);
	BTNode* node3 = BuyNode(3);
	BTNode* node4 = BuyNode(4);
	BTNode* node5 = BuyNode(5);
	BTNode* node6 = BuyNode(6);
	//开始链接
	node1->left = node2;
	node1->right = node4;
	node2->left = node3;
	node4->left = node5;
	node4->right = node6;
	

}

2.2 二叉树的遍历

2.2.1 前序、中序以及后序遍历

学习二叉树结构，最简单的方式就是遍历。所谓二叉树遍历是按照某种特定的规则，依次对二叉树中的节点进行相应的操作，并且每个节点只操作一次。访问结点所做的操作依赖于具体的应用问题。遍历是二叉树上最主要的运算之一，也是二叉树上进行其他运算的基础。

按照规则，二叉树的遍历有：前序/中序/后序的递归结构遍历：

  1. 前序遍历——访问根结点的操作发生在遍历其左右子树之前。
  2. 中序遍历——访问根结点的操作发生在遍历其左右子树之中。
  3. 后序遍历——访问根结点的操作发生在遍历其左右子树之后。

以后遇到二叉树就要拆解为根、左子树、右子树。每一个结点都要这样

对前序而言，如果我们通过顺序先访问1，到了访问2时，也要把2拆解为根（2），左子树（3），右子树（空）。先去访问左子树3，而3拆为根时左右子树都是null。然后再去访问根为2时的右子树（空）

以此类推继续访问根为1时的右子树（4）

我们先来按照这个形状来构建节点并链接起来

//搭建二叉树结构
typedef struct BinaryTreeNode
{
	struct BinaryTreeNode* left;
	struct BinaryTreeNode* right;
	int val;
}BTNode;

//创造节点
BTNode* BuyNode(int x)
{
	BTNode* node = (BTNode*)malloc(sizeof(BTNode));
	if (node == NULL)
	{
		perror("node faild");
		exit(-1);
	}
	node->val = x;
	node->left = NULL;
	node->right = NULL;
	return node;
}

int main()
{
	//手动构建节点
	BTNode* node1 = BuyNode(1);
	BTNode* node2 = BuyNode(2);
	BTNode* node3 = BuyNode(3);
	BTNode* node4 = BuyNode(4);
	BTNode* node5 = BuyNode(5);
	BTNode* node6 = BuyNode(6);
	//开始链接
	node1->left = node2;
	node1->right = node4;
	node2->left = node3;
	node4->left = node5;
	node4->right = node6;
	

}

前序遍历：

涉及到子问题嵌套子问题，是深入了解二叉树遍历分治（递归）的开始~

//前序遍历
void PrevOrder(BTNode* root)
{
	//当二叉树无根时
	if (root == NULL)
	{
        printf("NULL ");
		return;
	}
	//当二叉树有根时
	printf("%d ", root->val);
	PrevOrder(root->left);
	PrevOrder(root->right);
}

通过递归我们可以很轻易地写出前序遍历，而接下来我们就来分析二叉树递归遍历的精妙之处~

递归时每次函数都会建立一个栈帧。

前序遍历递归展开图：

一开始根是1，打印出来后走1的左子树2，2作为根打印后继续走2的左子树3，3作为根打印后走3的左子树，但此时3的左子树为空所以递进结束开始回归，回到根为3的时候继续走3的右子树，然而3的右子树也是空所以不再递进选择回归。而当我们遍历完3的左右子树后就会回到2作为根的那一层栈帧，因为2的左子树3已经被我们遍历完了，所以我们开始遍历2的右子树，发现2的右子树也是空所以不再递进选择回归，把2的左右子树也遍历完后我们再回归至根为1的那一层，因为2作为1的左子树已经遍历完了，所以我们接着对1的右子树4选择递进........就这样以此类推，当所以子树都递进后最终都会向根回归，达到前序遍历的作用。

所以该递归最核心的部分就是先打印根结点，然后再去找根结点的左右子树，通过这个规律我们可以轻易的模仿出中序遍历与后序遍历。

中序遍历递归图：

//中序遍历
void InOrder(BTNode* root)
{
	//当二叉树无根时
	if (root == NULL)
	{
		printf("NULL ");
		return;
	}
	//当二叉树有根时
	PrevOrder(root->left);
	printf("%d ", root->val);
	PrevOrder(root->right);
}

后序遍历：

//后序遍历
void PostOrder(BTNode* root)
{
	//当二叉树无根时
	if (root == NULL)
	{
		printf("NULL ");
		return;
	}
	//当二叉树有根时
	PostOrder(root->left);
	PostOrder(root->right);
	printf("%d ", root->val);
	
}

2.3节点个数

节点个数其实很简单，只需要遍历一遍，遍历的时候计数就可以了，下面我们来用前序遍历计节点个数（其实中序和后序也可以遍历）

//节点个数
int TreeSize(BTNode* root)
{
	int size = 0;
	//当二叉树无根时
	if (root == NULL)
	{
		return 0;
	}
	else
	{
		size++;
	}
	//当二叉树有根时
	PostOrder(root->left);
	PostOrder(root->right);
	
	return size;
}

注意，这种写法并不可取，因为我们在递归的时候都会建立栈帧，每一次递归都会建立一个size，这时候每一个size都是独立的，并不会叠加到同一个size上。

//节点个数
int TreeSize(BTNode* root)
{
	static int size = 0;
	//当二叉树无根时
	if (root == NULL)
	{
		return 0;
	}
	else
	{
		size++;
	}
	//当二叉树有根时
	PostOrder(root->left);
	PostOrder(root->right);
	
	return size;
}

如果我们使用static就可以叠加size

static int size是存放在静态区的，就不会受栈影响。但这种方法只能执行一次（计算一棵二叉树），如果我们要计算多棵二叉树的时候就不行了。（多次调用该函数节点数size会一直叠加，不会先初始化为0再计数）

//节点个数
int size = 0;
int TreeSize(BTNode* root)
{
	//当二叉树无根时
	if (root == NULL)
	{
		return 0;
	}
	else
	{
		size++;
	}
	//当二叉树有根时
	PostOrder(root->left);
	PostOrder(root->right);
	
	return size;
}

我们可以改用全局变量，然后每次调用完后再把size初始化为0即可。

当然最好的方法还是把它变成递归子问题：

采用分治的思想，如果我们想要知道学校的全部人数，我们可以找校长，校长就去找2个院长...以此类推到最后的8个班长进行汇报，再一一传给上级直至校长。而在这层层分包的过程中——（由上而下遍历，由下而上累加计数）。

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

之所以要+1是因为我们在算出所在根左右子树节点个数的同时还需要加上根自己的个数。

严格来说这算是一种后序遍历，先求左右再求自己。

2.4叶子节点个数

我们可以采用遍历左子树+右子树的形式（从左子树开始不断向下延申，到底后放返回去找右子树），递归返回左右子树相加的节点个数。方向是对的，但是注意我们写的是叶子节点的个数，不是上面代码所求空节点的个数，所以我们需要注意以下三点：

  • 当该节点为空时返回0
  • 当该节点是叶子时返回1
  • 既不是空节点也不是叶子时返回左右子树相加

核心就在于辨别节点，当不是特殊节点时就要向下继续寻找它的左右子树的节点是否为特殊节点，一直持续到找到特殊节点（空或叶子节点）。

2.5第K层的节点个数

我们首先得知道层数是相对而言的，假设我们要求的是第三层，转换为子问题时对于左子树的2而言第三层在它看来是第二层。所以这一次不是用分治就能搞定的事情。

当前树的第k层 = 左子树的第k-1层 + 右子树的第k-1层

所求1的第三层转换为所求2的第二层再转换为所求3的第一层。当我们求到对应层数时（假设k=3，来到了第三层）如果第三层没有节点则返回0，反之返回1.

所以最后对于节点2而言，它所属的左右子树节点共返回了1个节点。

//第K层的节点数
int TreeKLevel(BTNode* root, int k)
{
	assert(k > 0);
	//该节点为空时
	if (root == NULL)
	{
		return 0;
	}
	//到达目标层时
	if (k == 1)
	{
		return 1;
	}
	return TreeKLevel(root->left, k - 1) + TreeKLevel(root->right, k - 1);
}

不同于与之前的判断左右子树为空后才返回1，由于是要求层节点所以我们要添加层数的限制，当到达所求层数时需要返回1，而所求层数的标准就是前面例子所假设的（k=3,对位于第三层的3而言它就是第一层）。到不了所求层数那就判定为空节点，直接返回0即可。

故基本思路就是一开始K为3，即第一层，那么我们肯定得优先判断第一层本身是否存在，不存在直接返回0，如果存在但又不满足我们所求层数则继续遍历它的左右子树，就这样持续下去直到我们能够成功到达目标楼层（K为1），不能到达肯定是因为前面的判断生效即该子树为空节点。所以最为核心的地方就是我们要弄清楚k楼层之间的相对关系。

2.6 二叉树查找值为x的节点

很多人会犯上述的代码错误，我们用递归展开图来解释问题。

假设我们所寻值为3

从1开始遍历当找到所寻值3开始返回时并没有谁能够去接收这个返回节点。接收的意义有两层，一是接收找到的节点，二是判定找不到时继续去右子树寻找。这是一个层层往回返，层层接收的过程，不是说找到就能够直接返回的事情。

接下来看另外一个典型错误，这一次我们修改代码判断条件为||，如果左树找到就不用去右树找了。但是无论是或还是与它们最终的结果都只会是真与假即0与1，拿这个来作为节点的接收是很荒谬的。

这个错误是重复覆盖，虽然是多加了一个接收节点的指针，但是最终返回的永远都是右子树的节点，左子树一旦存储好节点遍历到右子树时还是会被其覆盖掉。

我们可以通过递归展开图来分析一下：

从1到2再到3本来就已经找到目标节点并且开始返回了，结果到2的时候又去遍历它的右子树去了，右子树为空返回空指针，把目标节点给覆盖了。所以我们设置接收节点还不够，还要分析什么时候才可以去遍历右子树。 

//二叉树查找值为x的节点
BTNode* TreeFind(BTNode* root, int x)
{
	//如果节点为空
	if (root == NULL)
	{
		return NULL;
	}
	//如果节点不为空且数值刚好找到
	if (root->val == x)
	{
		return root;
	}
	//设立接收节点
	BTNode* ret = NULL;
	ret = TreeFind(root->left, x);
	if (ret)
	{
		return ret;
	}
	ret = TreeFind(root->right, x);
	if (ret)
	{
		return ret;
	}
	//如果再判断左右子树后接收节点仍为空，则最终返回空
	return NULL;

}

上述代码才是正确写法，如果在左子树搜索到了就马上返回该节点到上一层，接着进行判断，如果接收节点指针ret不为空则代表找到，返回该节点。对于右子树也是同理，最后如果ret还是为空则代表没找到目的节点，返回NULL.

我们来分析一下递归展开图：

对左子树往下递归开始查找，但找到目的节点3时，将3这个节点返回到2节点处所设置的接收节点ret中，然后又判断ret不为空则return ret 继续返回到上一层即1节点处所设置的接收节点ret,判断不为空后才是返回到外面。

 接着我们来找值为4的节点。

箭头的起点与终点都已经明确地表示的ret所存储的节点类别。

2.7 二叉树的销毁

这里的递归条件使用后序遍历可以很方便地把所以节点销毁，如果使用前序还得额外用指针去保存根节点。

//销毁节点
void TreeDestory(BTNode* root)
{
	if (root == NULL)
	{
		return;
	}
	TreeDestory(root->left);
	TreeDestory(root->right);
	free(root);
}

核心就是通过遍历找到该子树最后的节点，然后依次从下往上销毁。左子树销毁完再去销毁右子树。

这里root==NULL可以直接替代root->left==NULL与root->right==NULL.

这里的root不需要去额外置空，因为这里面的形参不会影响到外面的实参。

2.8 层序遍历

对于层序遍历这里我们会利用队列先进先出的特点。

先把根（3）录进去。然后出队列。

（3）出队列后把它的孩子（4，5）带进来

就这样以此类推当4出队列的时候把4的孩子（1，2）带进队列

最后就会呈现出第一层出完就会把第二层带进去，第二层出完再把第三层带进去。上一层带下一层的思路持续下去。

// 层序遍历
void BinaryTreeLevelOrder(BTNode* root)
{
    //如果根节点存在则入队列
    if (root)
    {
        QueuePush(&q, root);
    }
    //开始进行出队列带孩子的循环
    while (!QueueEmpty(&q))
    {
        //设置一个节点存储节点，为了方便找它孩子
        BTNode* front = QueueFront(&q);
        printf("%d ", front->val);
        //判断左右孩子是否存在
        if (front->left)
        {
            QueuePush(&q, front->left);
        }
        if (front->right)
        {
            QueuePush(&q, front->right);
        }
        QueuePop(&q);
    }
    printf("\n");
}

2.9 判断是否是完全二叉树

这里我们只需要对层序遍历进行修改就行了，因为如果是完全二叉树那么最后一层一定是连续的，遇到空节点时按照连续的特性后面一定也是空节点，我们只需要排查队列里出现空节点时后续是否还有空节点即可。在出现空节点排查整个队列时，如果队列出现了非空节点，那么它一定不是完全二叉树。

// 判断是否是完全二叉树
bool BinaryTreeComplete(BTNode* root)
{
    //如果根节点存在则入队列
    if (root)
    {
        QueuePush(&q, root);
    }
    //开始进行出队列带孩子的循环
    while (!QueueEmpty(&q))
    {
        //设置一个节点存储节点，为了方便找它孩子
        BTNode* front = QueueFront(&q);
        //如果遇到空节点立马退出
        if (front == NULL)
        {
            break;
        }
        //不用再判断左右孩子是否存在
            QueuePush(&q, front->left);
            QueuePush(&q, front->right);
            QueuePop(&q);
    }
    //遇到空节点意味着进入判断，如果队列里有非空节点，则证明是非完全二叉树
    while (!QueueEmpty(&q))
    {
       
        BTNode* front1 = QueueFront(&q);
        QueuePop(&q);//把空节点排掉//删除的是队列的节点不会影响树的节点，所以后面树的节点还是可以正常访问的
        if (front1 != NULL)
        {
            QueueDestory(&q);
            return false;
        }
    }
    QueueDestory(&q);
    return true;
}

3.0 全部代码

//test.c

#define _CRT_SECURE_NO_WARNINGS 1


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

// 不是增删查改，学习二叉树结构
typedef struct BinaryTreeNode
{
	struct BinaryTreeNode* _left;
	struct BinaryTreeNode* _right;
	int _data;
}BTNode;

#include"Queue.h"

BTNode* BuyNode(int x)
{
	BTNode* node = (BTNode*)malloc(sizeof(BTNode));
	if (node == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}

	node->_data = x;
	node->_left = NULL;
	node->_right = NULL;

	return node;
}

// 二叉树前序遍历 

void BinaryTreePrevOrder(BTNode* root)

{

	if (root == NULL)

	{

		printf("NULL ");

		return ;

	}

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

	BinaryTreePrevOrder(root->_left);

	BinaryTreePrevOrder(root->_right);



}


// 二叉树中序遍历

void BinaryTreeInOrder(BTNode* root)

{

	if (root == NULL)

	{

		printf("NULL");

		return ;

	}

	BinaryTreeInOrder(root->_left);

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

	BinaryTreeInOrder(root->_right);

}



// 二叉树后序遍历

void BinaryTreePostOrder(BTNode* root)

{

	if (root == NULL)

	{

		printf("NULL");

		return ;

	}

	BinaryTreePostOrder(root->_left);

	BinaryTreePostOrder(root->_right);

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

}


// 二叉树节点个数

int BinaryTreeSize(BTNode* root)

{

	return root == NULL ? 0 : BinaryTreeSize(root->_left) + BinaryTreeSize(root->_right) + 1;

}


// 二叉树叶子节点个数

int BinaryTreeLeafSize(BTNode* root)

{

	if (root == NULL)

	{

		return 0;

	}

	//如果是叶子节点

	if (root->_left == NULL && root->_right == NULL)

	{

		return 1;

	}

	//以上都不是就继续遍历旗下左右子树

	return BinaryTreeLeafSize(root->_left) + BinaryTreeLeafSize(root->_right);



}




// 二叉树第k层节点个数

int BinaryTreeLevelKSize(BTNode* root, int k)

{



	if (root == NULL)

	{

		return 0;

	}

	//到达目标层

	if (k == 1)

	{

		return 1;

	}

	//相对层

	return BinaryTreeLevelKSize(root->_left, k - 1) + BinaryTreeLevelKSize(root->_right, k - 1);

}

// 二叉树销毁

void BinaryTreeDestory(BTNode* root)

{

	if (root == NULL)

	{

		return;

	}

	BinaryTreeDestory(root->_left);

	BinaryTreeDestory(root->_right);

	free(root);

}



// 二叉树查找值为x的节点

BTNode* BinaryTreeFind(BTNode* root, int x)

{

	if (root == NULL)

	{

		return NULL;

	}

	if (root->_data == x)

	{

		return root;

	}

	//接收节点

	BTNode* ret = NULL;

	ret = BinaryTreeFind(root->_left, x);

	if (ret)

	{

		return ret;

	}

	ret = BinaryTreeFind(root->_right, x);

	if (ret)

	{

		return ret;

	}

	//如果直到最后还是什么都没有，返回空

	return NULL;

}
// 层序遍历
void BinaryTreeLevelOrder(BTNode* root)
{
	Que q;
	QueueInit(&q);
	//如果根节点存在则入队列
	if (root)
	{
		QueuePush(&q, root);
	}
	//开始进行出队列带孩子的循环
	while (!QueueEmpty(&q))
	{
		//设置一个节点存储节点，为了方便找它孩子
		BTNode* front = QueueFront(&q);
		printf("%d ", front->_data);
		//判断左右孩子是否存在
		if (front->_left)
		{
			QueuePush(&q, front->_left);
		}
		if (front->_right)
		{
			QueuePush(&q, front->_right);
		}
		QueuePop(&q);
	}
	printf("\n");
}


// 判断是否是完全二叉树
bool BinaryTreeComplete(BTNode* root)
{
	Que q;
	QueueInit(&q);
	//如果根节点存在则入队列
	if (root)
	{
		QueuePush(&q, root);
	}
	//开始进行出队列带孩子的循环
	while (!QueueEmpty(&q))
	{
		//设置一个节点存储节点，为了方便找它孩子
		BTNode* front = QueueFront(&q);
		//如果遇到空节点立马退出
		if (front == NULL)
		{
			break;
		}
		//不用再判断左右孩子是否存在
		QueuePush(&q, front->_left);
		QueuePush(&q, front->_right);
		QueuePop(&q);
	}
	//遇到空节点意味着进入判断，如果队列里有非空节点，则证明是非完全二叉树
	while (!QueueEmpty(&q))
	{

		BTNode* front1 = QueueFront(&q);
		QueuePop(&q);//把空节点排掉//删除的是队列的节点不会影响树的节点，所以后面树的节点还是可以正常访问的
		if (front1 != NULL)
		{
			QueueDestroy(&q);
			return false;
		}
	}
	QueueDestroy(&q);
	return true;
}


int main()
{
	// 手动构建
	BTNode* node1 = BuyNode(1);
	BTNode* node2 = BuyNode(2);
	BTNode* node3 = BuyNode(3);
	BTNode* node4 = BuyNode(4);
	BTNode* node5 = BuyNode(5);
	BTNode* node6 = BuyNode(6);

	node1->_left = node2;
	node1->_right = node4;
	node2->_left = node3;
	node4->_left = node5;
	node4->_right = node6;

	BinaryTreePrevOrder(node1);
	printf("\n");

	BinaryTreeInOrder(node1);
	printf("\n");

	BinaryTreePostOrder(node1);
	printf("\n");

	printf("节点个数：%d\n", BinaryTreeSize(node1));

	//size = 0;
	//printf("%d\n", TreeSize(node1));
	printf("叶子节点个数：%d\n", BinaryTreeLeafSize(node1));

	printf("第2层节点个数：%d\n", BinaryTreeLevelKSize(node1,2));

	BTNode* ret = NULL;
	ret = BinaryTreeFind(node1, 2);
	if (ret == NULL)
	{
		printf("找不到\n");
	}
	else
	{
		printf("找到了\n");
	}

	BinaryTreeLevelOrder(node1);

	if (BinaryTreeComplete(node1))
	{
		printf("是完全二叉树");
	}
	else
	{
		printf("不是完全二叉树");
	}

	BinaryTreeDestory(node1);
	node1 = NULL;

	return 0;
}
//Queue.c
#define _CRT_SECURE_NO_WARNINGS 1
#include "Queue.h"

void QueueInit(Que* pq)
{
	assert(pq);

	pq->head = pq->tail = NULL;
	pq->size = 0;
}

void QueueDestroy(Que* pq)
{
	assert(pq);

	QNode* cur = pq->head;
	while (cur)
	{
		QNode* next = cur->next;
		free(cur);
		cur = next;
	}

	pq->head = pq->tail = NULL;
	pq->size = 0;
}

void QueuePush(Que* pq, QDataType x)
{
	assert(pq);

	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}

	newnode->data = x;
	newnode->next = NULL;

	if (pq->tail == NULL)
	{
		pq->head = pq->tail = newnode;
	}
	else
	{
		pq->tail->next = newnode;
		pq->tail = newnode;
	}

	pq->size++;
}

void QueuePop(Que* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	if (pq->head->next == NULL)
	{
		free(pq->head);
		pq->head = pq->tail = NULL;
	}
	else
	{
		QNode* next = pq->head->next;
		free(pq->head);
		pq->head = next;
	}

	pq->size--;
}

QDataType QueueFront(Que* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	return pq->head->data;
}

QDataType QueueBack(Que* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	return pq->tail->data;
}

bool QueueEmpty(Que* pq)
{
	assert(pq);

	return pq->head == NULL;
}

int QueueSize(Que* pq)
{
	assert(pq);

	return pq->size;
}

 

//Queue.h
#pragma once

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

typedef struct BinaryTreeNode* QDataType;
typedef struct QueueNode
{
	struct QueueNode* next;
	QDataType data;
}QNode;

typedef struct Queue
{
	QNode* head;
	QNode* tail;
	int size;
}Que;

void QueueInit(Que* pq);
void QueueDestroy(Que* pq);
void QueuePush(Que* pq, QDataType x);
void QueuePop(Que* pq);
QDataType QueueFront(Que* pq);
QDataType QueueBack(Que* pq);
bool QueueEmpty(Que* pq);
int QueueSize(Que* pq);

4b12323f94834afd9ec146a3c10df229.jpeg三.结语

在csdn欠下的债我要在这个寒假还清！！！与君共勉~最后感谢大家的观看，友友们能够学习到新的知识是额滴荣幸，期待我们下次相见~

玛丽亚后
关注
  • 30
    点赞
  • 踩
  • 30
    收藏
    觉得还不错? 一键收藏
  • 15
    评论
数据结构——二叉树先序、中序、后序及层次四种遍历（C语言版）
正弦定理的博客
12-09 35万+
数据结构——二叉树先序、中序、后序三种遍历二叉树先序、中序、后序三种遍历三、代码展示： 二叉树先序、中序、后序三种遍历 先序遍历：3 2 2 3 8 6 5 4 中序遍历：2 2 3 3 4 5 6 8 后序遍历: 2 3 2 4 5 6 8 3 三种遍历不同之处在，输出数据放在不同之处 三、代码展示： #include<stdio.h> #include<stdlib.h> typedef struct Tree{ int
数据结构——二叉树遍历
acslsr的博客
03-12 208
一、遍历 按照某种特定的次序，访问树中各个节点，且每个节点恰好被访问一次的操作成为遍历。在二叉树这种半线性结构中，如何合理对其节点遍历是我们需要认真学习的地方。 根据遍历顺序，有多种遍历策略。以节点本身被访问的次序分类，可分为先序（VLR）、中序（LVR）、后序（LRV）三种方式。 二、先序遍历 1.递归式 最通俗易懂的表达方式为递归式，及查看完节点本身后依次对左右子节点递归调用自己，代码如下：...
二叉树遍历算法的应用
04-11
课程设计文档 利用二叉树遍历算法的框架和思路，假设访问结点的具体操作不仅仅局限于输出结点数据域的值，而把访问延伸到对结点的判别、计数等其他操作。这样可以解决一些关于二叉树的其他实际问题。（1） 统计二叉树中结点总数m，叶子结点个数n0 (2) 求二叉树的树深
二叉树遍历及其应用
q793145253的博客
01-10 1599
二叉树的三种遍历算法的递归实现 特别说明：函数形参中的 void(*visit)(BinTreeNode *p) 代表：采用一个visit的指针指向某个函数，该函数的形参为BinTreeNode *p，该函数的实现体中可以对结点进行处理，传参时将外部函数名传入即可 前、中、后的差别仅在于 visit(subTree) 该语句的位置不同 1、前序遍历 template<class T> void PreOrder(BinTreeNode<T> *subTree, void(*visit
树（三）——二叉树遍历的应用
最新发布
在校生
11-09 1665
二叉树遍历的应用（求二叉树结点数、叶子结点数、输出叶子结点、二叉树高度、建立二叉链表存储的二叉树、二叉树相似性的判定、求结点的双亲）
二叉树遍历的应用
0start1的博客
10-26 829
二叉树遍历相关重要题目
数据结构——二叉树的生成与遍历
02-18
数据结构，实现二叉树的生成与遍历的算法。包含利用先序、中序、后序遍历二叉树算法，二叉树基本操作。（注意没有左子树或右子树时用@或#作为结束符号）
数据结构实验——二叉树的建立和遍历.zip
12-13
1.采用二叉链表作为存储结构，创建一棵二叉树； 2.用递归及非递归算法对二叉树实现先序遍历； 3.用递归及非递归算法对二叉树实现中序遍历； 4.用递归及非递归算法对二叉树实现后序遍历。 5.用递归遍历算法中的访问...
数据结构——二叉树的先序遍历
huaimaisui的博客
07-20 6017
数据结构——二叉树的先序遍历
二叉树的遍历及其应用
guojz049的博客
06-06 787
#include #include using namespace std; typedef int ElemType; typedef struct TreeNode *BinTree; typedef BinTree Position; typedef struct TreeNode //二叉树的表示 { ElemType Data; BinTree Left; Bi
二叉树的遍历的应用
weixin_39804483的博客
01-22 446
  //二叉树的定义 typedef struct _BinaryTreeNode { char data; //int ltag , rtag; struct _BinaryTreeNode *lchild; struct _BinaryTreeNode *rchild; }BTNode; /* 1、表达式(a-(b+c)*(d/e))存储在存储在以二叉链表为存储结构的二叉...
二叉树的应用—二叉树遍历的应用
num24的专栏
11-07 720
在以上讨论的遍历算法中，访问结点的数据域信息，即操作Visite（bt->data）具有更一般的意义，需根据具体问题，对bt 数据进行不同的操作。下面介绍几个遍历操作的典型应用。 1．查找数据元素 Search（bt，x）在bt 为二叉树的根结点指针的二叉树中查找数据元素x。查找成功时返回该结点的指针；查找失败时返回空指针。 算法实现如下，注意遍历算法中的Visite(bt->dat
二叉树的遍历与应用
精神小伙的博客
09-23 632
很多与二叉树相关的算法都是二叉树遍历算法的扩展，所以要熟练掌握对二叉树的各种遍历算法，包括前中后序，层序的递归和非递归算法实现 #include<iostream> #include<queue> #include<stack> #define ElemType int #define MaxSize 50 using namespace std; int widths[MaxSize]; typedef struct BiTNode{ ElemType data
二叉树的遍历应用1
Maestro_T的博客
11-12 453
二叉树的遍历是指按某种顺序访问树中的每个结点。由于二叉树具有递归的性质，一棵非空的二叉树可以看成是由根结点、左子树和右子树三部分组成，依次遍历这3个部分的信息，也就遍历了二叉树。 完全二叉树的顺序存储转链式存储 一颗完全二叉树存放在于一个一维数组T【n】中，从T【0】开始顺序读出各个结点的值，建立该二叉树的链表表示 由于一维数组从0号开始存放，所以结点i的左子女为2i+1,右子女为2i+2。 vo...
评论 15
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值