七、 二叉树学习1（代码随想录学习）

最新推荐文章于 2025-04-25 12:17:03 发布
最新推荐文章于 2025-04-25 12:17:03 发布
阅读量592 收藏 20
点赞数 21
分类专栏： 算法学习 文章标签： 学习 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Hxyle/article/details/146004861
版权

1. 理论基础

代码随想录：二叉树理论

C++中map、set、multimap，multiset的底层实现都是平衡二叉搜索树，所以map、set的增删操作时间时间复杂度是logn。而unordered_map、unordered_set，unordered_map、unordered_set底层实现是哈希表。

2. 二叉数的递归遍历

先序遍历

class Solution {
public:
	void preorder(TreeNode *cur, vector<int> &res) {
		if (cur == nullptr)
			return;
		res.push_back(cur->val);
		preorder(cur->left, res);
		preorder(cur->right, res);
	}

	vector<int> preorderTraversal(TreeNode* root) {
		vector<int> res;
		preorder(root, res);
		return res;
	}
};

后序遍历

class Solution {
public:
	void postorder(TreeNode *cur, vector<int> &res) {
		if (cur == nullptr)
			return;
		postorder(cur->left, res);
		postorder(cur->right, res);
		res.push_back(cur->val);
	}

	vector<int> postorderTraversal(TreeNode* root) {
		vector<int> res;
		postorder(root, res);
		return res;
	}
};

中序遍历

class Solution {
public:
	void inorder(TreeNode *cur, vector<int> &res) {
		if (cur == nullptr)
			return;
		inorder(cur->left, res);
		res.push_back(cur->val);
		inorder(cur->right, res);
	}

	vector<int> inorderTraversal(TreeNode* root) {
		vector<int> res;
		inorder(root, res);
		return res;
	}
};

3. 二叉树的迭代遍历

先序遍历

思路： 利用栈，将根结点存入栈中。对栈进行遍历，先将栈顶元素的值加入res数组中，在将右左指针依次放入栈中（**先加右孩子的原因是，先入栈的后出栈，遍历时就会后打印）。遍历完成，即可得到先序遍历的数组。

class Solution {
public:
	vector<int> preorderTraversal(TreeNode* root) {
		vector<int> res;
		stack<TreeNode*> st;
		if (root == nullptr)
			return res;
		st.push(root);
		while (!st.empty()) {
			res.push_back(st.top()->val);
			TreeNode* cur = st.top();
			st.pop(); // 将栈顶元素弹出
			// 判断栈顶元素是否存在左右孩子
			// 先存右孩子，因为栈为先进后出
			if (cur->right != nullptr) st.push(cur->right);
			if (cur->left != nullptr) st.push(cur->left);
			
		}
		return res;
	}
};

中序遍历

思路： 中序遍历是左中右，先访问的是二叉树顶部的节点，然后一层一层向下访问，直到到达树左面的最底部，再开始处理节点（也就是在把节点的数值放进result数组中），这就造成了处理顺序和访问顺序是不一致的。那么在使用迭代法写中序遍历，就需要借用指针的遍历来帮助访问节点，栈则用来处理节点上的元素。

class Solution {
public:
	vector<int> inorderTraversal(TreeNode* root) {
		vector<int> res;
		stack <TreeNode*> st;
		TreeNode* cur = root;
		while (!st.empty() || cur != nullptr) {
			// 先向深遍历左孩子，直到遍历到底层
			if (cur != nullptr) {
				st.push(cur);  // 将当前指针入栈
				cur = cur->left; // 左
			}
			else {  // 若当前指针为空
				cur = st.top();
				st.pop();
				res.push_back(cur->val); // 中
				cur = cur->right; // 右
			}
		}
		return res;
	}
};

后序遍历

思路： 序遍历是中左右，后序遍历是左右中，那么我们只需要调整一下先序遍历的代码顺序，就变成中右左的遍历顺序，然后在反转result数组，输出的结果顺序就是左右中了。

class Solution {
public:
	vector<int> postorderTraversal(TreeNode* root) {
		vector<int> res;
		stack<TreeNode*> st;
		if (root == nullptr) return res;
		st.push(root);
		// =》中右左
		while (!st.empty()) {
			TreeNode* cur = st.top();
			st.pop();
			res.push_back(cur->val);
			// 先加左孩子，再加有孩子，遍历时先遍历右孩子再左孩子
			if (cur->left != nullptr) st.push(cur->left);
			if (cur->right != nullptr) st.push(cur->right);
		}
		// 中右左=》左右中
		reverse(res.begin(), res.end());
		return res;
	}
};

4. 二叉树的统一迭代法

思路： 使用空指针标识已被操作过的结点，当遇到空指针时，添加进结果数组。就是要处理的节点放入栈之后，紧接着放入一个空指针作为标记。

关键代码：先/中/后序遍历，只需更改语句的顺序即可

if (cur->right != nullptr) st.push(cur->right);
st.push(cur);
st.push(nullptr);
if (cur->left != nullptr) st.push(cur->left);

中序遍历

class Solution {
public:
	vector<int> inorderTraversal(TreeNode* root) {
		vector<int> res;
		stack<TreeNode*> st;
		if (root != nullptr) st.push(root);
		while (!st.empty()) {
			TreeNode* cur = st.top();  // 记录栈顶指针
			if (cur != nullptr) { // 当栈顶指针非空时，添加其左右孩子结点
				st.pop(); // 弹出栈顶结点，防止重复操作
				// 当右孩子非空时，添加进栈
				if (cur->right != nullptr) st.push(cur->right);
				st.push(cur); // 再将中间结点入栈
				st.push(nullptr); // 添加空指针，表示该结点已添加左右孩子
				// 当左孩子非空时，添加进栈
				if (cur->left != nullptr) st.push(cur->left);
			}
			else { // 当遇到空结点时，即碰到表示中间结点已被标识
				st.pop();
				cur = st.top();
				st.pop();
				res.push_back(cur->val); // 将中间结点的值添加
			}
		}
		return res;
	}
};

先序遍历

class Solution {
public:
	vector<int> preorderTraversal(TreeNode* root) {
		vector<int> res;
		stack<TreeNode*> st;
		if (root != nullptr) st.push(root);
		while (!st.empty()) {
			TreeNode* cur = st.top();  // 记录栈顶指针
			if (cur != nullptr) { // 当栈顶指针非空时，添加其左右孩子结点
				st.pop(); // 弹出栈顶结点，防止重复操作
				// 当右孩子非空时，添加进栈
				if (cur->right != nullptr) st.push(cur->right);
				// 当左孩子非空时，添加进栈
				if (cur->left != nullptr) st.push(cur->left);
				st.push(cur); // 再将中间结点入栈
				st.push(nullptr); // 添加空指针，表示该结点已添加左右孩子
			}
			else { // 当遇到空结点时，即碰到表示中间结点已被标识
				st.pop();
				cur = st.top();
				st.pop();
				res.push_back(cur->val); // 将中间结点的值添加
			}
		}
		return res;
	}
};

后序遍历

class Solution {
public:
	vector<int> postorderTraversal(TreeNode* root) {
		vector<int> res;
		stack<TreeNode*> st;
		if (root != nullptr) st.push(root);
		while (!st.empty()) {
			TreeNode* cur = st.top();  // 记录栈顶指针
			if (cur != nullptr) { // 当栈顶指针非空时，添加其左右孩子结点
				st.pop(); // 弹出栈顶结点，防止重复操作
				st.push(cur); // 再将中间结点入栈
				st.push(nullptr); // 添加空指针，表示该结点已添加左右孩子
				// 当右孩子非空时，添加进栈
				if (cur->right != nullptr) st.push(cur->right);
				// 当左孩子非空时，添加进栈
				if (cur->left != nullptr) st.push(cur->left);
			}
			else { // 当遇到空结点时，即碰到表示中间结点已被标识
				st.pop();
				cur = st.top();
				st.pop();
				res.push_back(cur->val); // 将中间结点的值添加
			}
		}
		return res;
	}
};

5. 二叉树的层序遍历

  1. 二叉树的层序遍历
    思路： 利用队列将每个结点的值加入结果中，并将该结点的左右孩子加入队列。对整个队列进行遍历，直至遍历完所有结点。
class Solution {
public:
	vector<vector<int>> levelOrder(TreeNode* root) {
		vector<vector<int>> res;
		queue<TreeNode*> que;
		if (root == NULL) return res;
		que.push(root);
		while (!que.empty()) {
			int size = que.size(); // 使用size确定当前层的结点个数
			vector<int> vec; // 添加当前层的结果
			for (int i = 0; i < size; i++) {
				TreeNode* cur = que.front();
				que.pop();
				vec.push_back(cur->val);// 添加结点的val
				// 将左右孩子入队
				if (cur->left != NULL) que.push(cur->left);
				if (cur->right != NULL) que.push(cur->right);
			}
			res.push_back(vec);
		}
		return res;
	}
};

时间复杂度： O(n)
空间复杂度： O(n)

  1. 二叉树的层序遍历Ⅱ
    思路： 将层序遍历的结果直接反转即可
class Solution {
public:
    vector<vector<int>> levelOrderBottom(TreeNode* root) {
        vector<vector<int>> res;
		queue<TreeNode*> que;
		if (root == NULL) return res;
		que.push(root);
		while (!que.empty()) {
			int size = que.size(); // 使用size确定当前层的结点个数
			vector<int> vec; // 添加当前层的结果
			for (int i = 0; i < size; i++) {
				TreeNode* cur = que.front();
				que.pop();
				vec.push_back(cur->val);// 添加结点的val
				// 将左右孩子入队
				if (cur->left != NULL) que.push(cur->left);
				if (cur->right != NULL) que.push(cur->right);
			}
			res.push_back(vec);
		}
		reverse(res.begin(), res.end());
		return res;
    }
};
  1. 二叉树的右视图
    思路： 再二叉树的层序遍历的基础上，判断当前元素是否为本层的末尾元素即可。
class Solution {
public:
	vector<int> rightSideView(TreeNode* root) {
		vector<int> res;
		queue<TreeNode*> que;
		if (root == NULL)  return res;
		que.push(root);
		while (!que.empty()) {
			int size = que.size();
			int value = 0;
			for (int i = 0; i < size; i++) {
				TreeNode* cur = que.front();
				que.pop();
				value = cur->val;
				if (cur->left != NULL) que.push(cur->left);
				if (cur->right != NULL) que.push(cur->right);
			}
			res.push_back(value); // 添加末尾元素
		}
		return res;
	}
};
  1. 二叉树的平均值
    思路： 将层序遍历中的每层元素加入一个数组改为加和为一个值，添加进一个总数组中即可。
class Solution {
public:
	vector<double> averageOfLevels(TreeNode* root) {
		vector<double> res;
		queue<TreeNode*> que;
		if (root == NULL)  return res;
		que.push(root);
		while (!que.empty()) {
			int size = que.size();
			double value = 0;
			for (int i = 0; i < size; i++) {
				TreeNode* cur = que.front();
				que.pop();
				value += cur->val; // 计算本层的元素和
				if (cur->left != NULL) que.push(cur->left);
				if (cur->right != NULL) que.push(cur->right);
			}
			res.push_back(value / size); // 本层的均值
		}
		return res;
	}
};
  1. N叉树的层序遍历
    思路： 与层序遍历的解法相似，只不过将添加左右孩子改为添加全部孩子。
class Solution {
public:
	vector<vector<int>> levelOrder(Node* root) {
		vector<vector<int>> res;
		queue<Node*> que;
		if (root == NULL) return res;
		que.push(root);
		while (!que.empty()) {
			int size = que.size();
			vector<int> vec;
			for (int i = 0; i < size; i++) {
				Node* cur = que.front();
				que.pop();
				vec.push_back(cur->val); // 加入当前结点的值
				// 将孩子添加进队列
				for (int j = 0; j < cur->children.size(); j++)
					if (cur->children[j] != NULL)
						que.push(cur->children[j]);
			}
			res.push_back(vec);
		}
		return res;
	}
};
  1. 在每个树行中找最大值
    思路： 与求二叉树的右视图类似，只不过将求每行最右元素改为求每行最大值。在for循环中比较即可。
class Solution {
public:
	vector<int> largestValues(TreeNode* root) {
		vector<int> res;
		queue<TreeNode*> que;
		if (root == NULL)  return res;
		que.push(root);
		while (!que.empty()) {
			int size = que.size();
			int max = INT_MIN;
			for (int i = 0; i < size; i++) {
				TreeNode* cur = que.front();
				que.pop();
				if (max < cur->val)
					max = cur->val;
				if (cur->left != NULL) que.push(cur->left);
				if (cur->right != NULL) que.push(cur->right);
			}
			res.push_back(max); // 添加末尾元素
		}
		return res;
	}
};
  1. 填充每个节点的下一个右侧节点
    思路： 在层序遍历的基础，判断当前节点是否是 本层的末尾节点，若是，则不进行操作；若不是，则添加next。
class Solution {
public:
	Node* connect(Node* root) {
		queue<Node*> que;
		if (root == NULL) return root;
		que.push(root);
		while (!que.empty()) {
			int size = que.size();
			for (int i = 0; i < size; i++) {
				Node* cur = que.front();
				que.pop();
				// 当该结点非当层的末尾结点，且还有剩余元素时，添加next
				if (!que.empty() && i + 1 < size)
					cur->next = que.front();
				if (cur->left != NULL) que.push(cur->left);
				if (cur->right != NULL) que.push(cur->right);
			}
		}
		return root;
	}
};
  1. 填充每个节点的下一个右侧节点Ⅱ
    思路： 与上一题的思路相同
class Solution {
public:
    Node* connect(Node* root) {
        queue<Node*> que;
		if (root == NULL) return root;
		que.push(root);
		while (!que.empty()) {
			int size = que.size();
			for (int i = 0; i < size; i++) {
				Node* cur = que.front();
				que.pop();
				// 当该结点非当层的末尾结点，且还有剩余元素时，添加next
				if (!que.empty() && i + 1 < size)
					cur->next = que.front();
				if (cur->left != NULL) que.push(cur->left);
				if (cur->right != NULL) que.push(cur->right);
			}
		}
		return root;
    }
};
  1. 二叉树的最大深度
    思路： 只需要一个遍历在层序遍历的过程中记录深度即可
class Solution {
public:
	int maxDepth(TreeNode* root) {
		int depth = 0;
		queue<TreeNode*> que;
		if (root == NULL) return depth;
		que.push(root);
		while (!que.empty()) {
			int size = que.size();
			depth++;
			for (int i = 0; i < size; i++) {
				TreeNode* cur = que.front();
				que.pop();
				if (cur->left != NULL) que.push(cur->left);
				if (cur->right != NULL) que.push(cur->right);
			}
		}
		return depth;
	}
};
  1. 二叉树的最小深度
    思路： 与最大深度相似，但需要判断当前节点是否有左右孩子，若左右孩子均无，则直接返回当前深度，当前深度即为最小深度。
class Solution {
public:
	int minDepth(TreeNode* root) {
		int depth = 0;
		queue<TreeNode*> que;
		if (root == NULL) return depth;
		que.push(root);
		while (!que.empty()) {
			int size = que.size();
			depth++;
			for (int i = 0; i < size; i++) {
				TreeNode* cur = que.front();
				que.pop();
				if (cur->left != NULL) que.push(cur->left);
				if (cur->right != NULL) que.push(cur->right);
				// 当左右孩子均为空时，返回当前深度
				if (cur->left == NULL && cur->right == NULL) return depth;
			}
		}
		return depth;
	}
};
  1. 总结
    二叉树的层序遍历，就是图论中的广度优先搜索在二叉树中的应用，需要借助队列来实现

6. 翻转二叉树

leetcode链接

思路： 翻转二叉树，即将每个二叉树的左右孩子翻转，即可得到整个二叉树翻转的结果

层序遍历：

class Solution {
public:
	TreeNode* invertTree(TreeNode* root) {
		if (root == NULL) return root;
		queue<TreeNode*> que;
		que.push(root);
		while (!que.empty()) {
			int size = que.size();
			for (int i = 0; i < size; i++) {
				TreeNode* cur = que.front();
				que.pop();
				// 交换左右孩子
				swap(cur->left, cur->right);
				if (cur->left != NULL) que.push(cur->left);
				if (cur->right != NULL) que.push(cur->right);
			}
		}
		return root;
	}
};

先序遍历(递归法)：

class Solution {
public:
	void preorder(TreeNode* T) {
		if (T == NULL) return;
		// 翻转左右孩子
		swap(T->left, T->right);
		preorder(T->left);
		preorder(T->right);
	}

	TreeNode* invertTree(TreeNode* root) {
		if (root == NULL) return root;
		preorder(root);
		return root;
	}
};

先序遍历(迭代法)：

class Solution {
public:
	TreeNode* invertTree(TreeNode* root) {
		if (root == NULL) return root;
		stack<TreeNode*> st;
		st.push(root);
		while (!st.empty()) {
			TreeNode* cur = st.top();
			swap(cur->right, cur->left);
			st.pop();
			// 先加右孩子，后加左孩子
			if(cur->right!= NULL) st.push(cur->right);
			if (cur->left != NULL) st.push(cur->left);
		}
		return root;
	}
};

时间复杂度: O(n)

7. 二叉树周末总结

代码随想录：二叉树周末总结

七、二叉树学习4(代码随想录学习)
Hxyle的博客
03-16 965
代码随想录：二叉树总结4。
七、 二叉树学习2（代码随想录学习）
Hxyle的博客
03-08 843
代码随想录：二叉树周末总结Ⅱ。
代码随想录二叉树篇（含源码）
2402_88307286的博客
02-11 1299
本文是基于代码随想录上二叉树章节的所有例题及其对应的算法思路（序号代表的是力扣题号）
代码随想录+leetcode学习笔记
weixin_45746058的博客
04-02 345
代码随想录
代码随想录(一)：二叉树
weixin_62436171的博客
04-03 939
从二叉树开始学习~
二叉树 | 代码随想录学习笔记
qq_44250700的博客
08-10 260
二叉树的定义与链表差不多，只不过二叉树的节点里多了两个指针：指向左右孩子。
代码随想录学习笔记---二叉树
最新发布
qq_52276934的博客
04-25 127
学习代码随想录–二叉树。
力扣java刷题学习（代码随想录学习）1
weixin_44215785的博客
03-21 1558
自学使用
代码随想录学习笔记——二叉树（下）
程序猿进化梯
01-16 603
前言 参考代码随想录/LeetCode作的学习笔记。 特别赞同卡子哥的一句话，初学者刚开始学习算法的时候，看到简单题目没有思路很正常，千万别怀疑自己智商，学习过程都是这样的，大家智商都差不多。慢慢来，一切都会好起来~ 二叉树 题目链接 106. 从中序与后序遍历序列构造二叉树 难度级别 Mid 递归思路： 做这种题目要搞清楚以根结点为基准对左右子树需要实现哪些操作。首先后序遍历的最后一个结点是根结点，它先将中序序列划分为左右两个部分，再将后序序列划分为左右两个部分，然后再根据左右部分递归即可，结束条
代码随想录学习笔记——二叉树（上）
程序猿进化梯
01-17 865
代码随想录学习笔记——二叉树
代码随想录 动态规划、回溯、递归、二叉树、贪心
12-25
《代码随想录》是一本深受程序员喜爱的编程学习资料，尤其在算法领域，它提供了丰富的实例和深入的解析，帮助读者理解并掌握动态规划、回溯、递归、二叉树以及贪心等核心算法。这些算法是解决复杂计算问题的基础工具...
代码随想录算法PDF.zip
05-29
《代码随想录》是一本深受程序员喜爱的算法学习书籍，其PDF版本为读者提供了方便的电子阅读体验。这本书主要针对准备参加编程面试或者想要提升自己算法能力的开发者，通过实例解析和实战演练，帮助读者深入理解算法...
代码随想录的pdf版本，需要准备秋招的小伙伴们看过来呀！
02-28
通过学习《代码随想录》，你可以系统地了解和掌握这些基础知识，为面试和工作中的问题解决做好准备。 书中可能包含以下核心知识点： 1. **基础数据结构**：数组、链表、栈、队列、哈希表、二叉树等。理解这些数据...
代码随想录算法PDF.rar
08-06
《代码随想录》是一本深受程序员喜爱的算法学习书籍，尤其对于初学者来说，它提供了深入浅出的讲解和实战演练。这本书的核心是通过实际编程来帮助读者理解和掌握算法，提升编程技能，特别是C++语言的应用。在C++这个...
代码随想录：全面解析二叉树理论与应用实例
09-17
内容概要：本文来自《代码随想录》，详尽探讨了有关二叉树的各类知识。包含了二叉树的种类（满二叉树、完全二叉树）、平衡树、遍历方式及其实现代码，涵盖了深度与广度两种不同的搜索策略以及非递归的方法。本文适用...
【python】Asyncio包学习6-10
weixin_38805083的博客
04-21 1059
在Python的异步编程模块asyncio中，异步迭代器（Asynchronous Iterators）是一种特殊的迭代器，允许异步生成值。它实现了和方法，其中返回异步迭代器对象本身，返回一个coroutine协程对象，用于异步生成下一个值。异步迭代器工作方式与常规迭代器类似，但允许在迭代过程中异步生成值。当用于async for循环时，会异步生成迭代序列中的每个值，直到没有值可供生成。def __aiter__(self): # 注意__aiter__必须为普通方法。
Spring Boot中自定义404异常处理问题学习笔记
yuzheh521的博客
04-24 295
*** 自定义无权限访问的异常*/@Component@Autowired@Overridetry {// 从域名获取学校信息// 查询学校IDif (school!= null) {// 设置到SchoolContextHolder和请求属性} else {// 如果找不到学校，抛出异常throw new UnauthorizedAccessException("异常域名");} else {
【Python 学习笔记】 pip指令使用
老衲的少女心i~
04-23 182
当前文章记录的是我在学习过程的一些笔记和思考，可能存在有误解的地方，仅供大家参考，欢迎大家有问题指出~提示：以下是本篇文章正文内容，下面案例可供参考pip是一个现代的，通用的Python包管理工具。提供了对Python 包的查找、下载、安装、卸载功能，便于我们对Python的资源包进行管理。
HAL库(STM32CubeMX)——高级ADC学习、HRTIM（STM32G474RBT6）
贾saisai的博客
04-21 138
对cubemx的ADC的设置进行补充Mode：ADC 模式Independent mod 独立 ADC 模式，当使用一个 ADC 时是独立模式，使用两个 ADC 时是双模式，在双模式下还有很多细分模式可选Data Alignment：数据对齐Right alignment 右对齐Scan Conversion Mode：扫描模式，如果是多通道 AD 转换使用 ENABLE。Continuous Conversion Mode：连续转换 / 单次转换。Disabled 单次转换。
代码随想录算法精粹：动态规划、回溯、递归深度解析
《代码随想录》文档中关于二叉树的知识点可能包括： - 二叉树的遍历：前序遍历、中序遍历、后序遍历和层次遍历。 - 二叉树的创建和销毁：构建特定结构的二叉树，以及清理分配的内存。 - 特殊二叉树的实现：如二叉...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值