二叉树的层次遍历（C++）

最新推荐文章于 2024-06-18 13:52:22 发布
最新推荐文章于 2024-06-18 13:52:22 发布
阅读量6k 收藏 28
点赞数 5
分类专栏： leetcode题 文章标签： c++ leetcode 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42817333/article/details/125110191
版权

二叉树的层次遍历

102.二叉树的层次遍历

思路：二叉树层次遍历可以使用队列来进行遍历。

class Solution {	//二叉树的层次遍历
public:
	vector<vector<int>> levelOrder(TreeNode* root) {
		vector<vector<int>> result;
		queue<TreeNode*> que;
		if (root != nullptr){
			que.push(root);
		}
		while (!que.empty()) {
			vector<int> temp;
			int length = que.size();
			for (int i = 0; i < length; ++i) {
				TreeNode* tempNode = que.front();
				que.pop();
				temp.push_back(tempNode->val);
				if (tempNode->left) {
					que.push(tempNode->left);
				}
				if (tempNode->right) {
					que.push(tempNode->right);
				}
			}
			result.push_back(temp);
		}
		return result;
	}
};

107. 二叉树的层序遍历 II

思路：在上一题的基础上，把最后得到的结果直接反转即可。

class Solution {	//107. 二叉树的层序遍历 II
public:
	vector<vector<int>> levelOrderBottom(TreeNode* root) {
		vector<vector<int>> result;
		queue<TreeNode*> que;
		if (root != nullptr){
			que.push(root);
		}
		while (!que.empty()) {
			vector<int> temp;
			int length = que.size();
			for (int i = 0; i < length; ++i) {
				TreeNode* tempNode = que.front();
				que.pop();
				temp.push_back(tempNode->val);
				if (tempNode->left) {
					que.push(tempNode->left);
				}
				if (tempNode->right) {
					que.push(tempNode->right);
				}
			}
			result.push_back(temp);
		}
		reverse(result.begin(), result.end());
		return result;
	}
};

199. 二叉树的右视图

思路：本题可以使用双向队列deque，在102题的基础上稍作修改，在队列遍历完每一层时，将队列的最后一个节点加入到结果集result。这里改成双向队列，是因为双向队列可以直接取到队列尾部的值。

class Solution {	//199. 二叉树的右视图
public:
	vector<int> rightSideView(TreeNode* root) {
		vector<int> result;
		deque<TreeNode*> que;
		if (root != nullptr){
			que.push_back(root);
		}
		while (!que.empty()) {
			result.push_back(que.back()->val);
			int length = que.size();
			for (int i = 0; i < length; ++i) {
				TreeNode* tempNode = que.front();
				que.pop_front();
				if (tempNode->left) {
					que.push_back(tempNode->left);
				}
				if (tempNode->right) {
					que.push_back(tempNode->right);
				}
			}
		}
		return result;
	}
};

637. 二叉树的层平均值

思路：在102题的基础上，略作修改即可。

class Solution {	//637. 二叉树的层平均值
public:
	vector<double> averageOfLevels(TreeNode* root) {
		vector<double> result;
		queue<TreeNode*> que;
		if (root != nullptr){
			que.push(root);
		}
		while (!que.empty()) {
			double sum = 0;
			int length = que.size();
			for (int i = 0; i < length; ++i) {
				TreeNode* tempNode = que.front();
				que.pop();
				sum += tempNode->val;
				if (tempNode->left) {
					que.push(tempNode->left);
				}
				if (tempNode->right) {
					que.push(tempNode->right);
				}
			}
			double average = sum / (double)length;
			result.push_back(average);
		}
		return result;
	}
};

429. N叉树的层序遍历

思路：N叉树的层次遍历与二叉树的层次遍历流程相同，不同的地方在于二叉树是每次将队首节点的左右孩子加入队列，而N叉树是将队首节点的所有孩子加入队列，只要遍历存孩子节点的动态数组，将其加入队列即可。

class Solution {	//429. N叉树的层序遍历
public:
	vector<vector<int>> levelOrder(Node* root) {
		vector<vector<int>> result;
		queue<Node*> que;
		if (root != nullptr) {
			que.push(root);
		}
		while (!que.empty()) {
			vector<int> temp;
			int length = que.size();
			for (int i = 0; i < length; ++i) {
				Node* node = que.front();
				que.pop();
				temp.push_back(node->val);
				int size = (node->children).size();
				for (int j = 0; j < size; ++j) {
					que.push(node->children[j]);
				}
			}
			result.push_back(temp);
		}
		return result;
	}
};

515. 在每个树行中找最大值

思路：先用队列层序遍历，然后把每一层用优先级队列存储，优先级队列的队首就是树行中的最大值。

class Solution {	//515. 在每个树行中找最大值 使用队列和优先级队列
public:
	class myComparison {
	public:
		bool operator()(TreeNode* p1, TreeNode* p2) {
			return p1->val < p2->val;
		}
	};
	vector<int> largestValues(TreeNode* root) {
		vector<int> result;
		
		queue<TreeNode*> que;
		if (root) {
			que.push(root);
		}
		while (!que.empty()) {
			int length = que.size();
			priority_queue<TreeNode*, vector<TreeNode*>, myComparison> p_que;
			for (int i = 0; i < length; ++i) {
				TreeNode* node = que.front();
				que.pop();
				p_que.push(node);
				if (node->left) {
					que.push(node->left);
				}
				if (node->right) {
					que.push(node->right);
				}
			}
			result.push_back(p_que.top()->val);
		}
		return result;
	}
};

int main() {
	TreeNode* p6 = new TreeNode(9);
	TreeNode* p5 = new TreeNode(3);
	TreeNode* p4 = new TreeNode(5);
	TreeNode* p3 = new TreeNode(2, nullptr, p6);
	TreeNode* p2 = new TreeNode(3, p4, p5);
	TreeNode* p1 = new TreeNode(1, p2, p3);
	Solution s;
	vector<int> result = s.largestValues(p1);

	for (int i : result) {
		cout << i << "\t";
	}
	cout << endl;
	return 0;
}

116. 填充每个节点的下一个右侧节点指针
117. 填充每个节点的下一个右侧节点指针II

思路：用队列进行层次遍历，遍历每一层时，取出队首元素并弹出，next指针指向下一个队首元素即可。

class Node {
public:
	int val;
	Node* left;
	Node* right;
	Node* next;

	Node() : val(0), left(NULL), right(NULL), next(NULL) {}

	Node(int _val) : val(_val), left(NULL), right(NULL), next(NULL) {}

	Node(int _val, Node* _left, Node* _right, Node* _next)
	: val(_val), left(_left), right(_right), next(_next) {}
};


class Solution {	//116、117. 填充每个节点的下一个右侧节点指针
public:
	Node* connect(Node* root) {
		if (root == nullptr) return root;
		queue<Node*> que;
		que.push(root);
		while (!que.empty()) {
			int size = que.size();
			Node* node = nullptr;
			for (int i = 0; i < size; ++i) {
				node = que.front();
				que.pop();
				
				if (i < size - 1) {
					node->next = que.front();
				}
				if (node->left) {
					que.push(node->left);
				}
				if (node->right) {
					que.push(node->right);
				}
			}
		}
		return root;
	}
};

int main() {
	Node* p7 = new Node(7);
	Node* p6 = new Node(6);
	Node* p5 = new Node(5);
	Node* p4 = new Node(4);
	Node* p3 = new Node(3, p6, p7, nullptr);
	Node* p2 = new Node(2, p4, p5, nullptr);
	Node* p1 = new Node(1, p2, p3, nullptr);
	Solution s;
	s.connect(p1);

	return 0;
}

104. 二叉树的最大深度

思路：用队列层次遍历时记录层数。

class Solution {	//104. 二叉树的最大深度
public:
	int maxDepth(TreeNode* root) {
		int result = 0;
		queue<TreeNode*> que;
		if (root != nullptr){
			que.push(root);
		}
		while (!que.empty()) {
			int length = que.size();
			for (int i = 0; i < length; ++i) {
				TreeNode* tempNode = que.front();
				que.pop();
				if (tempNode->left) {
					que.push(tempNode->left);
				}
				if (tempNode->right) {
					que.push(tempNode->right);
				}
			}
			result++;
		}
		return result;
	}
};

111. 二叉树的最小深度

思路：用队列对二叉树进行层次遍历，在遍历时，记录层次，如果遇见叶子节点，就层数加1并返回记录的结果。

class Solution {	//111. 二叉树的最小深度
public:
	int minDepth(TreeNode* root) {
		int result = 0;
		queue<TreeNode*> que;
		if (root != nullptr){
			que.push(root);
		}
		while (!que.empty()) {
			int length = que.size();
			for (int i = 0; i < length; ++i) {
				TreeNode* tempNode = que.front();
				que.pop();
				if (tempNode->left == nullptr&&tempNode->right == nullptr) {
					result++;
					return result;
				}
				if (tempNode->left) {
					que.push(tempNode->left);
				}
				if (tempNode->right) {
					que.push(tempNode->right);
				}
			}
			result++;
		}
		return result;
	}
};

参考资料：代码随想录

海螺蜜
关注
  • 5
    点赞
  • 踩
  • 28
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
二叉树层次遍历（队列法、每层打印）——C++
净无邪博客
12-08 2878
由上面题目可知，输入是一个一维数组，输出是一个二维数组。其中输入一维数组中存储的是节点元素，输出二维数组是每层节点关键字打印。故知道该题主要考察二叉树基本的层次遍历方法，需要打印出每层节点的关键字。 二叉树的层次遍历实现思路是用一个队列记录每层节点，当记录第一层节点时，弹出第一层节点进行访问，访问的同时需要遍历对应节点的左右子节点压栈；当访问完一层节点时，此时改成节点所有左右子节点都已经压栈，由于先前循环弹出了第一层的n个节点，故当前队列只存储下一层所有节点，所以只需要将该队列大小保存，然后该轮循环中弹出这
数据结构实验3 二叉树层次遍历 二叉树的层次遍历
07-05
（3）掌握二叉树层次遍历算法程序。 实验内容及要求： （1）建立包含10个结点的二叉树（树结构和数据元素的值由自己设定）； （2）完成二叉树从左至右，从上至下层次遍历程序； （3）给出程序和遍历程序的结果。 ...
二叉树的层序遍历（c++）
qq_45519325的博客
02-24 1923
使用层序建树实现二叉树并进行层序遍历
【C++数据结构】二叉树的层序遍历
2301_80937868的博客
06-18 774
在线性结构中，每个结点只有一个后继。在有些情况下，一个结点可能有多个后继。树（tree）可以描述这类非线性结构，二叉树（Binary Tree)的递归定义如下：二叉树要么为空，要么由根节点（root）、左子树（left subrree）和右子树（right subtree）组成，而左子树和右子树分别是一颗二叉树。注意，在计算机中，树一般是“倒置”的，即根在上，叶子在下。本文将介绍二叉树的创建及层序遍历。
C++——二叉树的层序遍历
一抹阳光的博客
05-11 8347
二叉树的层序遍历：一般基于队列的实现 首先将二叉树的根节点push到队列中。 判断队列不为空就输出队头元素。 判断当前对头节点是否有孩子节点，有则push到队列中。 循环操作，直到队列为空。 代码如下： void FloorPrint_QUEUE(TreeNode* Tree) //层序遍历_队列实现 { queue < TreeNode* > q; if (Tree != NULL) q.push(Tree); //根节点进队列 whil
二叉树的层次遍历（c++）
qq_44799835的博客
08-13 7525
层次遍历 ：对于一颗二叉树，从根结点开始，按从上到下，从左到右的顺序访问每一个结点 思路 使用队列 1，将根结点入队 2，队不为空时循环：出列一个结点，打印它 ①有左孩子，将左孩子入队 ②有右孩子，将右孩子入队在这里插入代码片 #include<iostream> #include<queue> using namespace std; typedef struct TriTNode{ struct TriTNode *lchild; struct TriTNode *rchil
C++-- 二叉树的层序遍历
weixin_53946312的博客
10-24 1434
二叉树的层序遍历 题目要求： 题目来源：力扣 class Solution { public: vector<vector<int>> levelOrder(TreeNode* root) { if(root == nullptr) { return vector<vector<int>> (); } queue<TreeNode*> q;
二叉树的层次遍历(python&C++)
06-07
二叉树的层次遍历，思路与实现
层次遍历二叉树
10-24
层次遍历二叉树
使用 C++ 实现二叉树层次遍历的示例代码
06-05
二叉树的层次遍历 该程序使用队列实现了二叉树的层次遍历，同时使用了广义表表示法来创建二叉树。程序先创建好一棵二叉树，然后调用 levelOrder 函数即可得到该二叉树的层次遍历结果。
二叉树的层次遍历-C++实现
12-15
本文将详细讨论如何用C++语言实现二叉树的层次遍历。 首先，我们定义了一个`Tree`结构体，包含一个数据成员`data`以及指向左右子节点的指针`lchild`和`rchild`。这里使用了`typedef`关键字，使得我们可以用`Tree`来...
二叉树的层次遍历 c++实现
04-19
实现树的层次遍历 利用c++代码实现。。。。。。。
二叉树层次遍历（C++）
qq_33804124的博客
11-30 346
/** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode() : val(0), left(nullptr), right(nullptr) {} * TreeNode(int x) : val(x), left(nullptr), right(nullptr) {} *
二叉树的层次遍历c++
weixin_43845922的博客
08-01 803
层次遍历算法层次遍历代码完整测试代码 算法 借助一个队列，先将二叉树根节点入队列，然后出队列，访问出队结点。 若出队结点有左子树，则将左子树根结点入队； 若出队结点有右子树，则将右子树根节点入队。 然后出队，访问出队结点，重复 2，直至队列为空 层次遍历代码 void LevelOrder(BiTree T){ LinkQueue Q; InitQueue(Q); BiTree p=T; EnQueue(Q,p); while(!IsEmpty(Q)){
C++二叉树层序遍历
PETERPARKERRR的博客
10-28 2766
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录一、pandas是什么？二、使用步骤1.引入库2.读入数据总结 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可供参考 一、pandas是什么？ 示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。 二、使用步骤 1.引入库 代码如下（示
二叉树的层序遍历（C++详解）
m0_50655389的博客
01-11 1202
本篇文章使用C++实现了二叉树的层序遍历。
二叉树的先序、中序、后序、层次四种遍历（递归和非递归）
crawer
06-11 710
二叉树的遍历 我这里写了二叉树的四种遍历算法： 二叉树的先序、中序、后序 —— 递归和非递归 二叉树的层次遍历 —— 非递归遍历 OK 开始我们的正文！要看完整代码直接滑动到最后！ 在进行各种遍历算法前，先创建我们的二叉树：下图是随便画的一个二叉树，我们就创建这个二叉树 定义结点 并且 创建二叉树 （这里是将有关的代码从源代码中摘出来放在一起） //定义节点 typedef struct Node { char date; //存储结点数据 struct Node
二叉树的遍历总结
qq_42582489的博客
11-18 597
二叉树的遍历总结 文章目录二叉树的遍历总结二叉树结构建立二叉树层次遍历递归的三种遍历非递归的三种遍历完整代码 二叉树结构 用二叉链表来存储二叉树 typedef struct BiTNode //二叉树 { int data; //结点数值 struct BiTNode *lchild; struct BiTNode *rchild; }BiTNode, *BiTree; 建立二叉树 输入一个数组，以层次遍历的顺序进行建树，规定数组元素都大于0。当数组元素为-1时，表示该结点为空。 举个例子，比如数
二叉树层次遍历C++
最新发布
06-28
二叉树的层次遍历，也称为广度优先搜索（Breadth-First Search, BFS），是一种按照从上到下、从左到右的顺序逐层遍历树节点的方法。在C++中，我们可以使用队列数据结构来实现这一过程，因为队列的特点是先进先出（FIFO），非常适合处理二叉树的层次遍历。 以下是一个简单的C++代码示例，展示了如何使用层次遍历方法遍历二叉树： ```cpp #include <iostream> #include <queue> using namespace std; // 定义二叉树结点 struct TreeNode { int val; TreeNode* left; TreeNode* right; TreeNode(int x) : val(x), left(NULL), right(NULL) {} }; // 层次遍历函数 void levelOrderTraversal(TreeNode* root) { if (root == nullptr) return; queue<TreeNode*> q; // 创建一个队列 q.push(root); // 将根节点入队 while (!q.empty()) { int size = q.size(); // 当前层的节点数量 for (int i = 0; i < size; i++) { TreeNode* node = q.front(); // 弹出队首元素 cout << node->val << " "; // 访问节点值 // 将子节点入队，继续下一层 if (node->left) q.push(node->left); if (node->right) q.push(node->right); } cout << endl; // 每层结束后换行 q.pop(); // 出队已访问的节点 } } int main() { // 示例：创建一个二叉树并进行层次遍历 TreeNode* root = new TreeNode(1); root->left = new TreeNode(2); root->right = new TreeNode(3); root->left->left = new TreeNode(4); root->left->right = new TreeNode(5); levelOrderTraversal(root); // 输出：1 2 3 4 5 return 0; } ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

海螺蜜

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值