代码随想录算法训练营第14天 | 二叉树的深度优先遍历

纵使啰嗦始终关注

已于 2024-01-10 15:40:56 修改

阅读量409

点赞数 5

文章标签：算法深度优先

于 2024-01-09 21:18:52 首次发布

本文链接：https://blog.csdn.net/qq_44173169/article/details/135477480

版权

二叉树理论基础

二叉树的种类

满二叉树：树中只有度为0和2的节点，并且度为0的节点在同一层上。
完全二叉树：除了最底层可能没有填满，其他层的节点数都达到了最大值，并且最底层的节点都集中在该层最左侧的若干位置。最底层节点数目为1 ~ 2 x (h - 1)，h 从1开始。

比如上一节中的优先级队列是一个堆，堆就是一个完全二叉树。
二叉搜索树：是一个有序树。满足若左子树不为空，则左子树上的节点数值均小于它的根节点的值；若右子树不为空，则右子树上的节点数值均大于它的根节点的值；左右子树也是二叉搜索树。
平衡二叉树：也被称为 AVL树。具有以下性质：是一棵空树或它的左右子树高度差的绝对值不大于1，同时左右子树都是平衡二叉树。C++中的 set、multiset、map、multimap 的底层实现就是平衡二叉搜索树，因此增删时间复杂度为 O(logn)。

存储方式

顺序存储与链式存储，顺序就是用数组，链式就是用指针。
注意数组存储时，如果父节点的索引下标是 i，那么它的左孩子下标是 2 x i + 1，由孩子是 2 x i + 2。

遍历方式

深度优先搜索(DFS)：先往深走，遇到叶子节点再往回走。前序、中序、后序（迭代法、递归法）
广度优先搜索(BFS)：一层一层地去遍历。层序（迭代法）
在 DFS 中有三种遍历顺序，前中后指的是中间节点的遍历位置。
Alt
DFS 往往用递归实现更加方便，由于栈是实现递归的一种方式，所以可以借助栈来实现。BFS 需要逐层遍历，先进先出的队列更适合实现。

二叉树定义

struct TreeNode{
	int val;
	TreeNode* left;
	TreeNode* right;
	TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};

二叉树的递归遍历

递归方法论：1. 确定递归函数的参数与返回值；2. 确定终止条件；3. 确定单层递归的逻辑。
其实递归就是一个拆解任务的过程，验证递归算法可以设计一些简单的例子进入递归，但更好的理解方式是将递归函数作为一个已知的处理步骤或量，这样就会发现递归的思维是最直接、最容易理解的。
前序遍历

class Solution{
public:
	// 我们只需要记录节点的元素值，所以传入的参数为节点和结果数组即可，也不用返回任何值
	void traversal(TreeNode* node, vector<int>& res){
		if(node == NULL)  return;
		res.push_back(node->val);  // 记录中间节点的值
		traversal(node->left, res);  // 遍历左子树
		traversal(node->right, res);  // 遍历右子树
	}
	vector<int> preorderTraversal(TreeNode* root){
		vector<int> result;
		traversal(root, result);
		return result;
	}
};

中序遍历

class Solution{
public:
	void traversal(TreeNode* node, vector<int>& res){
		if(node == NULL)  return;
		traversal(node->left, res);  // 左节点递归调用
		res.push_back(node->val);  // 中间节点的值加入结果数组
		traversal(node->right, res);  // 右节点递归调用
	}
	vector<int> inorderTraversal(TreeNode* root){
		vector<int> result;
		traversal(root, result);
		return result;
	}
};

后序遍历

class Solution{
public:
	void traversal(TreeNode* node, vector<int>& res){
		if(node == NULL)  return;
		traversal(node->left, res);  // 左
		traversal(node->right, res);  // 右
		res.push_back(node->val);  // 中
	}
	vector<int> postorderTraversal(TreeNode* root){
		vector<int> result;
		traversal(root, result);
		return result;
	}
};

递归函数传入参数要注意传入 vector 指针，保证更改了结果数组。

二叉树的迭代遍历

我们知道在每次递归调用把函数的中间变量、参数、返回地址压入调用栈中，递归返回时从栈顶弹出这些参数，实现返回时总是可以返回上一层。
我们前面用递归实现了前中后序遍历，所以从原理上看应该可以使用迭代算法、借助栈结构来实现递归效果。
前序遍历：

class Solution{
public:
	vector<int> preorderTraversal(TreeNode* root){
		stack<TreeNode*> st;
		vector<int> result;
		// 需要注意不要把空指针放入栈中
		if(root == NULL)  return result;
		st.push(root);
		while(!st.empty()){
			TreeNode* node = st.top();
			st.pop();
			result.push_back(node->val);  // 处理中间节点
			if(node->right)  st.push(node->right);    // 将右节点压入栈中
			if(node->left)  st.push(node->left);  // 将左节点压入栈中
		}
		return result;
	}
};

递归实现遍历中可以稍稍改动递归函数内的逻辑（左中右节点的处理顺序），从而实现前中后序的遍历。那么借助栈的迭代法是否也能简单修改代码逻辑顺序呢？
答案是不能的。我们将遍历节点的过程称为访问，将把元素放入结果数组称为处理。在前序遍历中，访问和处理是同时进行的，所以只用一个栈就能实现访问和处理，但中序和后序中访问和处理都是分开的，必须先处理最左节点，但是要想达到最左节点，必须从根节点开始访问，前面的那些节点只能访问不能处理，这样单用一个栈是无法实现的，只能换一种风格，用指针访问，用栈进行处理。
中序遍历：

class Solution{
public:
	vector<int> inorderTraversal(TreeNode* root){
		vector<int> result;
		if(root == NULL)  return result;
		stack<TreeNode*> st;
		TreeNode* cur = root;  // 定义一个指针来遍历节点
		while(cur != NULL || !st.empty()){  // 空指针说明已经遍历完，空栈说明已经处理完
			if(cur != NULL){
				st.push(cur);
				cur = cur->left;  // 如果左侧还有节点，一直往左遍历
			}
			else{
				TreeNode* node = st.top();  
				st.pop();
				result.push_back(node->val);  // 处理中间节点
				cur = node->right;  // 遍历右侧节点
			}
		}
		return result;
	}
};

对于后序遍历，有两种风格，一种是延续前序的风格，前序是中左右，后序是左右中，我们只需要在前序代码中先将左节点压栈，后将右节点压栈，变顺序为中右左，最终在整体进行翻转，就得到左右中了。另一种是延续中序遍历的风格，但在添加中间节点时需要添加判断其右节点是否已经处理。
后序遍历：

class Solution{
public:
	vector<int> postorderTraversal(TreeNode* root){
		vector<int> result;
		if(root == nullptr)  return result;
		stack<TreeNode*> st;
		st.push(root);
		while(!st.empty()){
			TreeNode* node = st.top();
			st.pop();
			result.push_back(node->val);  // 遍历到中间节点，直接处理
			if(node->left)  st.push(node->left);  // 左节点压栈
			if(node->right)  st.push(node->right);  // 右节点压栈，下一轮处理先处理的就是右侧
		}
		reverse(result.begin(), result.end());  // 中右左->左右中
		return result;
	}
};

class Solution{
public:
	vector<int> postorderTraversal(TreeNode* root){
		stack<TreeNode*> st;
		vector<int> result;
		if(root == NULL)  return result;
		TreeNode* cur = root;
		TreeNode* prev = NULL;
		while(cur != NULL || !st.empty()){
			if(cur != NULL){
				st.push(cur);
				cur = cur->left;
			}
			else{
				TreeNode* node = st.top();
				st.pop();
				if(prev == node->right || node->right == NULL){  // 判断该节点的右节点是空还是已经处理了
					result.push_back(node->val);
					prev = node;
				}
				else{
					cur = node->right;
					st.push(node);
				}
			}
		}
	}
	return result;
};

二叉树的统一遍历法

在迭代法中前中后序的实现代码风格是不统一的，由于访问和处理有不同步的情况，需要用指针访问，用栈进行处理。但我们用标记法可以实现风格上统一的迭代法。我们把访问的节点放进栈中，同时也把要处理的节点标记后放进栈中。如何标记呢？把要处理的节点放入栈后，再添加一个空指针作为标记。
中序遍历：

class Solution{
public:
	vector<int> inorderTraversal(TreeNode* root){
		stack<TreeNode*> st;
		vector<int> result;
		if(root == NULL)  return result;
		st.push(root);
		while(!st.empty()){
			TreeNode* node = st.top();  // 取出栈顶元素
			st.pop();
			if(node != NULL){  // 如果不是空指针，这不是需要处理的节点，应该继续向下遍历
				// 要注意空节点不入栈
				if(node->right)  st.push(node->right);  // 右节点先入栈，最后再处理
				st.push(node);  // 标记中间节点，下一次遇到直接处理
				st.push(NULL);
				if(node->left)  st.push(node->left);  // 左节点最后入栈，下一轮可以从左节点开始遍历
			}
			else{  // 
				TreeNode* node = st.top();
				st.pop();
				result.push_back(node->val);
			}
		}
		return result;
	}
};

这样我们只改变没遇到空节点时的处理顺序，就可以实现前中后序的遍历。
前序遍历：

class Solution{
public:
	vector<int> preorderTraversal(TreeNode* root){
		stack<TreeNode*> st;
		vector<int> result;
		if(root == NULL)  return result;
		st.push(root);
		while(!st.empty()){
			TreeNode* node = st.top();
			st.pop();
			if(node != NULL){
				if(node->right)  st.push(node->right);
				if(node->left)  st.push(node->left);
				st.push(node);
				st.push(NULL);
			}
			else{
				TreeNode* node = st.top();
				st.pop();
				result.push_back(node->val);
			}
		}
		return result;
	}
};

后序遍历：

class Solution{
public:
	vector<int> postorderTraversal(TreeNode* root){
		vector<int> result;
		if(root == NULL)  return result;
		stack<TreeNode*> st;
		st.push(root);
		while(!st.empty()){
			TreeNode* node = st.top();
			st.pop();
			if(node != NULL){
				st.push(node);
				st.push(NULL);
				if(node->right)  st.push(node->right);
				if(node->left)  st.push(node->left);
			}
			else{
				TreeNode* node = st.top();
				st.pop();
				result.push_back(node->val);
			}
		}
		return result;
	}
};

纵使啰嗦始终关注

关注

5
点赞
踩
8

收藏

觉得还不错? 一键收藏
0
评论
代码随想录算法训练营第14天 | 二叉树的深度优先遍历

int val;
复制链接

扫一扫