数据结构——二叉树遍历和常见问题

已于 2022-04-22 21:56:21 修改
阅读量2.9k 收藏 18
点赞数 4
文章标签： 数据结构
于 2022-04-22 18:18:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_57133901/article/details/124333487
版权

树的概念：

1.树的概念

要了解二叉树的遍历规则必须先要知道树的结构和概念。
树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因
为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。

  • 根结点：根节点没有前驱结点。
  • 除根节点外，其余结点被分成是一棵结构与树类似的子树。每棵子树的根结点有且只有一个前驱，可以有0个或多个后继。 因此，树是递归定义的。

在这里插入图片描述

  • 节点的度：一个节点含有的子树的个数称为该节点的度； 如上图：A的为2
  • 叶节点：度为0的节点称为叶节点； 如上图：C、E、F、H节点为叶节点
  • 非终端节点或分支节点：度不为0的节点； 如上图：B、D、G节点为分支节点
  • 双亲节点或父节点：若一个节点含有子节点，则这个节点称为其子节点的父节点； 如上图：A是B的父节点
  • 孩子节点或子节点：一个节点含有的子树的根节点称为该节点的子节点； 如上图：B是A的孩子节点
  • 兄弟节点：具有相同父节点的节点互称为兄弟节点； 如上图：B、G是兄弟节点
  • 树的度：一棵树中，最大的节点的度称为树的度； 如上图：树的度为2
  • 节点的层次：从根开始定义起，根为第1层，根的子节点为第2层，以此类推；
  • 树的高度或深度：树中节点的最大层次； 如上图：树的高度为4
  • 堂兄弟节点：双亲在同一层的节点互为堂兄弟；如上图：H、C互为兄弟节点
  • 节点的祖先：从根到该节点所经分支上的所有节点；如上图：A是所有节点的祖先
  • 子孙：以某节点为根的子树中任一节点都称为该节点的子孙。如上图：所有节点都是A的子孙
  • 森林：由m棵互不相交的树的集合称为森林；

特殊的二叉树：

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

在这里插入图片描述

在这里插入图片描述
完全二叉树其实也很好判断，在二叉树的最后一层，如果是从右向左依次缺失的满二叉树就是完全二叉树，如：
在这里插入图片描述
这个二叉树就不是完全二叉树，红色节点处，他先失去了左孩子，没有失去右孩子。不满足从右向左依次缺失。

二叉树遍历

概念：

所谓遍历(Traversal)是指沿着某条搜索路线，依次对树中每个结点均做一次且仅做一次访问。访问结点所做的操作依赖于具体的应用问 题。 遍历是二叉树上最重要的运算之一，是二叉树上进行其它运算之基础。
前序/中序/后序的递归结构遍历：是根据访问结点操作发生位置命名

  • NLR：前序遍历(Preorder Traversal 亦称先序遍历)——访问根结点的操作发生在遍历其左右子树之前。

  • LNR：中序遍历(Inorder Traversal)——访问根结点的操作发生在遍历其左右子树之中（间）。

  • LRN：后序遍历(Postorder Traversal)——访问根结点的操作发生在遍历其左右子树之后。

    由于被访问的结点必是某子树的根，所以N(Node）、L(Left subtree）和R(Right
    subtree）又可解释为根、根的左子树和根的右子树。NLR、LNR和LRN分别又称为先根遍历、中根遍历和后根遍历。

可能这样的解释不容易理解，下边我们画图看看二叉树的遍历方式。

在这里插入图片描述
不管是哪种遍历规则，所走的路径就是这样，区别是对双亲节点的读取顺序。
就拿先序遍历举例，先序遍历是先读取双亲节点，再读取左右节点，从根节点A进入，读取A，遍历他的左子树，到达B点，读取B点，以此类推。上图先序遍历为：ABCDEFGH
中序遍历：先遍历左子树，再读取双亲节点，再遍历右子树上图中序遍历为：CBEDFAGH
后序遍历：先遍历左子树，再遍历右子树，再读取双亲节点，上图后序遍历为：CEFDBHGA

实现：

然后就是代码实现了。
首先是节点类型：

typedef char ElemType;
typedef struct BtNode // BinaryTreeNode
{
	ElemType data;
	struct BtNode* leftchild;
	struct BtNode* rightchild;
}BtNode, * BinaryTree;

先序遍历（递归实现）：

void PreOrder(BtNode* p)
{
	if (p != NULL)
	{
		cout << p->data << " ";
		PreOrder(p->leftchild);
		PreOrder(p->rightchild);
	}
}

先序遍历（非递归实现）：

void   NicePreOreder(BtNode* ptr)//非递归先序遍历
{
	if (ptr == NULL) return;
	std::stack<BtNode*>st;
	while (ptr != NULL || !st.empty())
	{
		while (ptr != NULL)
		{
			st.push(ptr);
			cout << ptr->data;
			ptr = ptr->leftchild;
		}
		ptr = st.top(); st.pop();
		
		ptr = ptr->rightchild;
		
	}
	cout << endl;
}

中序遍历（递归实现）：

void InOrder(BtNode* p)
{
	if (p != NULL)
	{
		InOrder(p->leftchild);
		cout << p->data << " ";
		InOrder(p->rightchild);
	}
}

中序遍历（非递归实现）：

void   NiceInOreder(BtNode* ptr)//非递归中序遍历
{
	if (ptr == NULL) return;
	std::stack<BtNode*>st;
    while(ptr!=NULL || !st.empty())
	{ 
	while (ptr != NULL)
	{
		st.push(ptr);
		ptr = ptr->leftchild;
	}
	ptr = st.top(); st.pop();
	cout << ptr->data;
	ptr = ptr->rightchild;
	}
	cout << endl;
}

后序遍历（递归实现）：

void PastOrder(BtNode* p)
{
	if (p != NULL)
	{
		PastOrder(p->leftchild);
		PastOrder(p->rightchild);
		cout << p->data << " ";
	}
}

后序遍历（非递归实现）：

void NicePastOrder(BtNode* ptr)//非递归后序遍历
{
	if (ptr == NULL)return;
	std::stack<BtNode*>st;
	BtNode* tag = NULL;//用于解决右子树是有被访问过
	while (ptr != NULL || !st.empty())
	{
		while (ptr != NULL)
		{
			st.push(ptr);
			ptr = ptr->leftchild;
		}
		ptr = st.top(); st.pop();
		if (ptr->rightchild == NULL || ptr->rightchild == tag)
		{
			cout << ptr->data;
			tag = ptr;
			ptr = NULL;
		}
		else
		{
			st.push(ptr);
			ptr = ptr->rightchild;

		}
		
	}
}

二叉树常见问题：

1.节点个数：

递归：

int Cout(BtNode* ptr)//节点个数
{
	if (ptr == NULL)return 0;
	else return (Cout(ptr->leftchild) + Cout(ptr->rightchild) + 1);
}

非递归：

通过队列来记录导入的节点，每次导入一层的所有节点数，每导入一次节点，节点数+1。

int Cout1(BtNode* ptr)
{
	if (ptr == 0)return 0;
	deque<BtNode*>qu;
	qu.push_back(ptr);
	int num = 0;
	while (!qu.empty())
	{
		int n = qu.size();
		for (int i = 0; i < n; i++)
		{
			ptr = qu.front(); qu.pop_front();
			if (ptr->leftchild != NULL)
			{
				qu.push_back(ptr->leftchild);
				
			}
			if (ptr->rightchild != NULL)
			{
				qu.push_back(ptr->rightchild);
			}
			num++;
		}
		
	}
	return num;
}

2.二叉树的深度：

递归：

int depth(BtNode* ptr)//深度
{
	if (ptr == NULL)return 0;
	else return max(depth(ptr->leftchild), depth(ptr->rightchild)) + 1;
}

非递归：

通过队列来记录导入的节点，每次导入一层的所有节点数，深度+1。

int depth1(BtNode* ptr)//深度（非递归）
{
	if (ptr == 0)return 0;
	deque<BtNode*>qu;
	qu.push_back(ptr);
	int num = 0;
	while (!qu.empty())
	{
		int n = qu.size();
		for (int i = 0; i < n; i++)
		{
			ptr = qu.front(); qu.pop_front();
			if (ptr->leftchild != NULL)
			{
				qu.push_back(ptr->leftchild);

			}
			if (ptr->rightchild != NULL)
			{
				qu.push_back(ptr->rightchild);
			}	
		}
		num++;
	}
	return num;
}

3. Z字打印：

利用两个栈来回进行导入子树节点，要注意的一点就是两个栈导入节点时，因为要进行Z字打印，一个栈先导入左子树，一个栈先导入右子树。

void Zprintf(BtNode* ptr)//Z字打印，利用两个栈来回导出数据
{
	if (ptr == NULL)return;
	std::stack<BtNode*>ast;
	std::stack<BtNode*>bst;
	ast.push(ptr);
	while (!ast.empty() || !bst.empty())
	{
		while (!ast.empty())
		{
			ptr = ast.top(); ast.pop();
			cout << ptr->data;
			if (ptr->leftchild != NULL)
			{
				bst.push(ptr->leftchild);
			}
			if (ptr->rightchild != NULL)
			{
				bst.push(ptr->rightchild);
			}
		}
		while (!bst.empty())
		{
			ptr = bst.top(); bst.pop();
			cout<<ptr->data;
			if (ptr->rightchild != NULL)
			{
				ast.push(ptr->rightchild);
			}
			if (ptr->leftchild != NULL)
			{
				ast.push(ptr->leftchild);
			}
		}
	}
}

4.判断是否是满二叉树：

判断是否是满二叉树，利用两个队列，如果每两层的差值是第一层的两倍是满二叉树。

bool IS_fullTree(BtNode* ptr)//判断是否是满二叉树，利用两个队列，如果每两层的差值是第一层的两倍是满二叉树。
{
	bool tag = true;
	if (ptr == NULL)return tag;
	std::queue<BtNode*>aqu;
	std::queue<BtNode*>bqu;
	int s = 1;
	aqu.push(ptr);
	while (!aqu.empty() || !bqu.empty())
	{
		if (s != aqu.size())
		{
			tag = false;
			break;
		}
		while (!aqu.empty())
		{
			ptr = aqu.front(); aqu.pop();
			if (ptr->leftchild != NULL)
			{
				bqu.push(ptr->leftchild);
			}
			if (ptr->rightchild != NULL)
			{
				bqu.push(ptr->rightchild);
			}
		}
		s += s;
		if (s != bqu.size())
		{
			tag = false;
			break;
		}
		while (!bqu.empty())
		{
			ptr = bqu.front(); aqu.pop();
			if (ptr->leftchild != NULL)
			{
				aqu.push(ptr->leftchild);
			}
			if (ptr->rightchild != NULL)
			{
				aqu.push(ptr->rightchild);
			}
		}
	}
	return tag; 
}

5.判断是否是完全二叉树：

判断是不是完全二叉树，用队列来，保证最后一层保存的节点的后边全是空

bool IS_Comptree(BtNode* ptr)//判断是不是完全二叉树，用队列来，保证最后全是空
{
	bool tag = true;
	if (ptr == NULL)return true;
	queue<BtNode*>qu;
	qu.push(ptr);
	while (!qu.empty())
	{
		ptr = qu.front(); qu.pop();
		if (ptr == NULL)break;
		qu.push(ptr->leftchild);
		qu.push(ptr->rightchild);
	}
	while (!qu.empty())
	{
		if (ptr != NULL)
		{
			tag = false;
			break;
		}
		qu.pop();
	}
	return tag;
}

6.任选两种遍历顺序构建二叉树

先写出两个重要的函数，构造节点的函数和查找节点的函数。
构造节点：

BtNode* Buynode()
{
	BtNode* s = (BtNode*)malloc(sizeof(BtNode));
	if (NULL == s)exit(1);
	memset(s, 0, sizeof(BtNode));
	return s;
}

查找节点：

int FindIs(const char* is, int n, char ch)
{
	int pos = -1;
	for (int i = 0; i < n; ++i)
	{
		if (is[i] == ch)
		{
			pos = i;
			break;
		}
	}
	return pos;
}

前中构建：

BtNode* CreatePI(const char* ps, const char* is, int n)//前中构建
{
	BtNode* s = NULL;
	if (n >= 1)
	{
		s = Buynode();
		s->data = ps[0];
		int pos = FindIs(is, n, ps[0]);
		if (pos == -1) exit(1);
		s->leftchild = CreatePI(ps + 1, is, pos);
		s->rightchild = CreatePI(ps + pos + 1, is + pos + 1, n - pos - 1);
	}
	return s;
}

中后构建：

BtNode* CreateIL(const char* is, const char* ls, int n)//中后构建
{
	BtNode* s = NULL;
	if (n > 0)
	{
		s = Buynode();
		s->data = ls[n - 1];
		int pos = FindIs(is, n, ls[n - 1]);
		s->leftchild = CreateIL(is,ls,pos);
		s->rightchild = CreateIL(is+pos+1,ls+pos,n-pos-1);

	}
	return s;

}

写在最后:

二叉树的大部分问题解决并不困难，一定要有自己的想法，对所有问题都要基于他特殊的树形结构来解决。二叉树特有的结构使他很多问题都可以使用递归方式解决，而能使用递归解决，同时也可以使用栈和队列来实现非递归解决。加粗样式面试时，很多问题考虑递归的同时，也需要有非递归解决的思路。

丿安桥
关注
  • 4
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
数据结构实验——二叉树的建立和遍历.zip
12-13
1.采用二叉链表作为存储结构，创建一棵二叉树； 2.用递归及非递归算法对二叉树实现先序遍历； 3.用递归及非递归算法对二叉树实现中序遍历； 4.用递归及非递归算法对二叉树实现后序遍历。 5.用递归遍历算法中的访问...
二叉树四种遍历方式的速度差异
na_beginning的专栏
03-15 3256
同学阿里三面面试官的一道面试题是：二叉树每个节点都保存一个整数，想要求所有节点数值之和，哪种遍历方式最快？首先定义二叉树struct Tree { int val; Tree *left; Tree *right; Tree(){val = 0;left = NULL;right = NULL;}; };Tree* constructTree(vector<int>
【数据结构学习】-二叉树的概念与遍历
Kevin_zhai的博客
08-27 1094
链表、栈或队列都是线性结构，包含一个数据元素序列。而二叉树是一种层次结构。一颗二叉树要么为空，要么由一个数据元素（称为跟）和两颗独立的二叉树（称为左子树和右子树）。某个节点的左（右）子树的根节点称为该节点的左（右）孩子节点。两颗子树均为空的节点称为叶子节点。 搜索二叉树：其左子树任意节点的值都小于此节点的值，其右子树中任意节点的值都大于此节点的值。 完全二叉树：如果一颗二叉树除最后一层外都保证
二叉树的常见问题及其解决程序
热门推荐
randyjiawenjie的专栏
09-13 3万+
二叉树的常见问题有如下几个，如果解决好了，就跟链表一样轻松：唯一不一样的是，二叉树是非线性结构。常见的问题如下： 二叉树的问题 1.二叉树三种周游（traversal）方式： 二叉树的问题 1.二叉树三种周游（traversal）方式： 2.怎样从顶部开始逐层打印二叉树结点数据 3.如何判断一棵二叉树是否是平衡二叉树 4.设计一个算法，找出二叉树上任意两个节点的最近共同父结点，复杂度如果
二叉树常见问题
天青如水的博客
10-29 426
1.两颗二叉树A和B，判断B是不是A的子结构 /* 思路：1.在树A中找到和B的根节点一样的节点R 2.判断树A以R为根节点的子树是不是包含和树B一样的结构 */ bool DoesTree1HaveTree2(BiTreeNode*T1,BiTreeNode*T2); bool HasSubtree(BiTreeNode*T1,BiTreeNode*T2) { bool ...
数据结构——二叉树的相关问题
华数云图小分队的博客
04-07 622
该程序是一个二叉树的创建和遍历示例，主要介绍了前序遍历、中序遍历、后序遍历、求二叉树节点数、求二叉树高度、求第 k 层的节点数等功能。通过这个程序我们可以更深入的理解二叉树的相关知识。在实现过程中，需要注意以下几点：二叉树的遍历方式有三种：前序遍历、中序遍历和后序遍历。在实现过程中需要注意节点的访问顺序。计算二叉树节点数和高度时，需要使用递归的方法。在计算节点数时，可以利用递归来进行累加；在计算高度时，则需要计算左右子树的高度，并比较取最大值。
数据结构之二叉树——相关问题总结
AugustWind的专栏
05-05 693
最近发现二叉树貌似很受面试官青睐，明天要参加某大型互联网公司二面，来总结总结热热身的说。二叉树顾名思义每个节点最多有两个孩子节点，由于二叉树的建立本身就是一个递归的过程，所以很多二叉树相关问题都可以使用递归的方法进行求解，但是也有很多面试官喜欢问×××的非递归实现。下面对一些常见的二叉树问题进行总结，原帖使用C，本小博用Java改写了一下。原文地址：http://blog.csdn.net/luc
数据结构——二叉树的生成与遍历
02-18
数据结构，实现二叉树的生成与遍历的算法。包含利用先序、中序、后序遍历二叉树算法，二叉树基本操作。（注意没有左子树或右子树时用@或#作为结束符号）
数据结构——二叉树
02-06
该文件包括二叉树的头文件（BitTree开头）和堆栈的头文件（Seq开头），另外还实现了编写按层次顺序（同一层自左至右）遍历二叉树的算法、后序递归遍历计算二叉树的深度的算法、判断给定二叉树是否为完全二叉树（通过...
数据结构——二叉树 线索化二叉树 C语言
03-16
中序线索二叉树，反方向进行中序遍历(要求非递归，顺前驱进行)。 （1）建立二叉树； (2) 按先序、中序、后序输出二叉树; （3）复制二叉树； （4）在字符模式下画出无缺陷的二叉树
数据结构——基于C语言实现二叉树的应用.cpp
08-11
/创建二叉树 //初始化二叉树 //创建队列 //出队 //队列判空 //入队 //先序递归遍历 //后序递归遍历 //中序递归遍历 //层次遍历
二叉树的常见问题
luanqibaazao的博客
06-26 483
一用两个栈实现队列 入队：直接入栈A 出队：判断栈B是否为空 如果B为空，A中元素先出栈，再入栈B 2. 二叉树的常见问题1 二叉树的常见问题及其解决程序 http://blog.csdn.net/randyjiawenjie/article/details/6772145 （1.二叉树三种周游（traversal）方式： （2.怎样从顶部开始逐层打印二叉树结点数据 （3.如何判断一棵二叉
数据结构与算法——二叉树问题
小葵坤_易安的博客
08-26 579
一、二叉树的基本概念 从逻辑结构角度来看，链表、栈、队列都是线性结构；而“二叉树”属于树形结构。 多叉树的基本概念，以上图中“多叉树”为例说明 节点：多叉树中的每一个点都叫节点；其中最上面的那个节点叫“根节点”； 根节点：位于树顶部的节点； 父节点：节点1是节点2/3/4/5/6的父节点，然后节点2/3/4/5/6是节点1的子节点；节点2/3/4/5/6又是互为兄弟节点，因为它们...
数据结构--顺序表经典OJ题
最新发布
zy1215058242的博客
05-02 410
给你两个按排列的整数数组nums1和nums2，另有两个整数m和n，分别表示nums1和nums2中的元素数目。请你nums2到nums1中，使合并后的数组同样按排列。最终，合并后数组不应由函数返回，而是存储在数组nums1中。为了应对这种情况，nums1的初始长度为m + n，其中前m个元素表示应合并的元素，后n个元素为0，应忽略。nums2的长度为n。设计实现一个时间复杂度为O(m + n)的算法解决此问题.解：对于这道题来说我们有多种思路，但是在限制了时间复杂度后，三变量就是最好的方法。
C++数据结构——中序遍历二叉树
05-23
中序遍历是二叉树遍历的一种，遍历顺序为左子树、根节点、右子树。以下是C++代码实现： ```c++ #include using namespace std; struct TreeNode { int val; TreeNode* left; TreeNode* right; TreeNode(int x...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值