【二叉树】（一）二叉树基础知识及多种遍历方式

代码随想录二叉树链接：二叉树理论基础
相关配套视频教程：二叉树基础

关于二叉树，该了解这些

二叉树的种类

• 满二叉树： 节点数 2^k-1 (k为深度)
• 完全二叉树： 除了底层以外，其他层都是满的，并且底层从左往右是连续的。
• 二叉搜索树： 左子数的所有节点都小于中间节点，右子数的所有节点都大于中间节点，同时左右子树也都满足这个规律。
• 平衡二叉搜索树： 左右两个⼦树的⾼度差的绝对值不超过1

存储方式

• ☆链式存储：数据域，左子树和右子树
• 线性存储：用字符数组保存数据，对每个节点进行标序（左子树下标：2 * i + 1；右子树下标：2 * i + 2）

遍历方式

1. 深度优先搜索： 沿着一个方向搜索，一直到终点后回退

• ☆前序遍历、中序遍历、后续遍历，递归实现
  • 前序遍历：中左右
  • 中序遍历：左中右
  • 后续遍历：左右中
  • 这里的左右指的的左右子树
• 也可以用栈模拟实现，递归的实现过程就是用栈实现递归的行为
• 迭代法（非递归方式）也可以分别实现前中后序遍历

2. 广度优先搜索： 一层一层的搜索或者一圈一圈的搜索

• 层序遍历就是广度优先搜索
• 层序遍历就是用的迭代法，用队列原理实现

节点定义

struct TreeNode{
	int val;					//节点数据
	struct TreeNode *left;		//左子树
	struct TreeNode *right;		//右子树
	TreeNode():	val(0),left(NULL),right(NULL){}			//无参构造
	TreeNode(int x):val(x),left(NULL),right(NULL){}		//只有值构造
	TreeNode(int x, TreeNode* left, TreeNode* right):
		val(x),left(left),right(right){}
};

二叉树的三种递归遍历（深度遍历）

递归遍历设计核心思想

以前序遍历为例：

• 【确定递归函数的参数与返回值】
    因为要打印出前序遍历节点的数值，所以参数里需要传入vector来放节点的数值，除了这一点就不需要再处理什么数据了也不需要有返回值，所以递归函数返回类型就是void，代码如下：

  void traversal(TreeNode* cur, vector<int>& vec)
  

• 【确定终止条件】
    在递归的过程中，如何算是递归结束了呢，当然是当前遍历的节点是空了，那么本层递归就要结束了，所以如果当前遍历的这个节点是空，就直接return，代码如下：

  if(cur == NULL)
  	return ;
  

• 【确定单层递归逻辑】
    序遍历是中左右的循序，所以在单层递归的逻辑，是要先取中节点的数值，代码如下：

  vec.push_back(cur->val);    // 中
  traversal(cur->left, vec);  // 左
  traversal(cur->right, vec); // 右
  

中序遍历程序：

void traversal(TreeNode* cur, vector<int>& vec) 
{
    if (cur == NULL) return;
    traversal(cur->left, vec);  // 左
    vec.push_back(cur->val);    // 中
    traversal(cur->right, vec); // 右
}

后续遍历程序：

void traversal(TreeNode* cur, vector<int>& vec) {
    if (cur == NULL) return;
    traversal(cur->left, vec);  // 左
    traversal(cur->right, vec); // 右
    vec.push_back(cur->val);    // 中
}

此时可以做一做leetcode上三道题目练练手，分别是：

• 144. 二叉树的前序遍历
• 94. 二叉树的中序遍历
• 145. 二叉树的后序遍历

递归遍历力扣例题解析

144. 二叉树的前序遍历
  定义 preorder(root) 表示当前遍历到 root 节点的答案。按照定义，我们只要首先将 root 节点的值加入答案，然后递归调用 preorder(root->left) 来遍历 root 节点的左子树，最后递归调用 preorder(root->right) 来遍历 root 节点的右子树即可，递归终止的条件为碰到空节点。

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

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

94. 二叉树的中序遍历
对于中序和后序遍历机制与前序遍历一样，只需要更改左中右顺序即可

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

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

145. 二叉树的后序遍历

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

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

二叉树的三种迭代遍历（深度遍历）

  递归的实现就是：每一次递归调用都会把函数的局部变量、参数值和返回地址等压入调用栈中，然后递归返回的时候，从栈顶弹出上一次递归的各项参数，所以这就是递归为什么可以返回上一层位置的原因，因此用栈也可以实现二叉树的前后中序遍历。

前后续遍历

  前序遍历是中左右，每次先处理的是中间节点，那么先将根节点放入栈中，然后将右孩子加入栈，再加入左孩子。
为什么要先加入 右孩子，再加入左孩子： 因为这样出栈的时候才是中左右的顺序。
动画如下：

不难写出如下代码:

vector<int> preorderTraversal(TreeNode* root) 
	{
		stack<TreeNode*> st;	//栈
		vector<int> res;		//结果容器
		TreeNode* node;			//栈顶节点
		st.push(root);			//根节点入栈
		while(!st.empty())		
		{
			node = st.top();	//获取栈顶节点并弹出
			st.pop();
			//中
			if(node != NULL)	//非空元素加入数组
				res.push_back(node->val);
			else
				continue;
			//左右节点 先放右子树再放左子树入栈
			//这样出栈才达到中左右顺序
			if(node->right)				//空节点不入栈
				st.push(node->right);
			if(node->left)
				st.push(node->left);
		}
		return res;
    }

  再来看后序遍历，先序遍历是中左右，后续遍历是左右中，那么我们只需调整一下先序遍历的代码顺序，就变成中右左的遍历顺序，然后再反转res数组，输出的结果顺序就是左右中了，如下图：

所以后序遍历只需要前序遍历的代码稍作修改就可以了，代码如下：

vector<int> postorderTraversal(TreeNode* root) 
{
	stack<TreeNode*> st;	//栈
	vector<int> res;		//结果容器
	TreeNode* node;			//栈顶节点
	st.push(root);			//根节点入栈
	while(!st.empty())
	{
		node = st.top();	//获取栈顶节点并弹出
		st.pop();
		//中
		if(node != NULL)	//非空元素加入数组
			res.push_back(node->val);
		else
			continue;
		//左右节点 先放左子树再放右子树入栈
		//出栈顺序: 中右左
		if(node->left)				
			st.push(node->left);
		if(node->right)
			st.push(node->right);
	}
	//将结果反转之后就是左右中的顺序了
	reverse(res.begin(), res.end());
	return res;
}

中序遍历

在刚刚在迭代的过程中，其实我们有两个操作：

• 处理： 将元素放进result数组中
• 访问： 遍历节点

  分析一下为什么刚刚写的前序遍历的代码，不能和中序遍历通用呢，因为前序遍历的顺序是中左右，先访问的元素是中间节点，要处理的元素也是中间节点，所以刚刚才能写出相对简洁的代码，因为要访问的元素和要处理的元素顺序是一致的，都是中间节点。
  那么再看看中序遍历，中序遍历是左中右，先访问的是二叉树顶部的节点，然后一层一层向下访问，直到到达树左面的最底部，再开始处理节点（也就是在把节点的数值放进result数组中），这就造成了处理顺序和访问顺序是不一致的。

  那么在使用迭代法写中序遍历，就需要借用指针的遍历来帮助访问节点，栈则用来处理节点上的元素。

中序遍历，可以写出如下代码：

//中序遍历
vector<int> middleorderTraversal(TreeNode* root) 
{
	stack<TreeNode*> st;	//栈 记录遍历过的节点
	vector<int> res;		//结果容器
	TreeNode* cur = root;	//遍历节点
	while(cur != NULL || (!st.empty()))
	{
		if(cur != NULL)			// 指针来访问节点，访问到最底层
		{
			st.push(cur);		//访问指针入栈
			cur = cur->left;	//左
		}
		else					//到左端极限
		{
			cur = st.top();		//记录栈弹出节点
			st.pop();			
			res.push_back(cur->val);	//节点元素放进数组 中
			cur = cur->right;			//右
		}
	}
	return res;
}

二叉树的层序遍历（广度遍历）

学会二叉树的层序遍历，可以一口气打完以下十题：

• 102.二叉树的层序遍历
• 107.二叉树的层次遍历II
• 199.二叉树的右视图
• 637.二叉树的层平均值
• 429.N叉树的层序遍历
• 515.在每个树行中找最大值
• 116.填充每个节点的下一个右侧节点指针
• 117.填充每个节点的下一个右侧节点指针II
• 104.二叉树的最大深度
• 111.二叉树的最小深度

层序遍历的思想与实现

  层序遍历一个二叉树，就是从左到右一层一层的去遍历二叉树。需要借用一个辅助数据结构即队列来实现，队列先进先出，符合一层一层遍历的逻辑，而用栈先进后出适合模拟深度优先遍历也就是递归的逻辑。
  而这种层序遍历方式就是图论中的广度优先遍历，只不过我们应用在二叉树上。

使用队列实现二叉树广度优先遍历，动画如下：

• 102.二叉树的层序遍历

代码如下：这份代码也可以作为二叉树层序遍历的模板，打十个就靠它了。

vector<vector<int>> levelOrder(TreeNode* root) 
{
	queue<TreeNode*> que;		//定义队列
	vector<vector<int>> res;	//结果容器
	TreeNode* node = root;		//当前节点
	int size = 0;
	//为空
	if(root != NULL)
		que.push(root);
	
	while(!que.empty())		
	{
		vector<int> vec;		//每一层的数组
		size = que.size();		//记录当前层节点数量
	
		//弹出当前层节点数量 并把下一层节点加入队列
		while(size--)
		{
			node = que.front();
			vec.push_back(node->val);	//队列数据加入结果数组
			que.pop();
			//左右子树入队列
			if(node->left)
				que.push(node->left);
			if(node->right)
				que.push(node->right);
		}
		//更新队列大小
		size = que.size();
		//层数组加入结果容器
		res.push_back(vec);
	}
	return res;
}

层序遍历力扣十题分析

107.二叉树的层次遍历II
  给定一个二叉树，返回其节点值自底向上的层次遍历。 （即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）

思路：
  相对于102.二叉树的层序遍历，就是最后把结果result数组反转一下就可以了

 reverse(result.begin(), result.end()); 

199.二叉树的右视图

  给定一棵二叉树，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。

思路
  层序遍历的时候，判断是否遍历到单层的最后面的元素，如果是，就放进result数组中，随后返回result就可以了。

while(!que.empty())		
{
	size = que.size();	//记录当前层节点数量
	while(size--)		//弹出当前层节点数量 并把下一层节点加入队列
	{
		node = que.front();
		if(size == 0)	//每一层最右侧节点数据加入结果数组
			res.push_back(node->val);	
		que.pop();	
		
		//左右子树入队列
		if(node->left)
			que.push(node->left);
		if(node->right)
			que.push(node->right);
	}
	size = que.size();	//更新队列大小
}

637.二叉树的层平均值
  给定一个非空二叉树, 返回一个由每层节点平均值组成的数组。
思路
  本题就是层序遍历的时候把一层求个总和在取一个均值。

while(!que.empty())		
{
	len = size = que.size();	//记录当前层节点数量
	while(size--)		//弹出当前层节点数量 并把下一层节点加入队列
	{
		node = que.front();
		sum += node->val;	
		que.pop();	
		
		//左右子树入队列
		if(node->left)
			que.push(node->left);
		if(node->right)
			que.push(node->right);
	}
	res.push_back(1.0 * sum / len);
	sum = 0;
	size = que.size();	//更新队列大小
}

429.N叉树的层序遍历

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

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

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

104.二叉树的最大深度

111.二叉树的最小深度