学习内容
力扣算法
144.二叉树的前序遍历
94.二叉树的中序遍历
145.二叉树的后序遍历
102.二叉树的层序遍历
前言
二叉树有两种遍历方式：
深度优先遍历：前中后序遍历
广度优先遍历：层序遍历
一般实现二叉树的遍历都用****递归
若要以非递归（迭代的形式）实现深度优先遍历：使用栈的数据结构
以非递归（迭代的形式）实现广度优先遍历：使用队列的数据结构
具体内容
144.二叉树的前序遍历
给你二叉树的根节点 root ，返回它节点值的 前序 遍历。
示例 1： 输入：root = [1,null,2,3] 输出：[1,2,3]
示例 2： 输入：root = [] 输出：[]
示例 3： 输入：root = [1] 输出：[1]
示例 4： 输入：root = [1,2] 输出：[1,2]
示例 5： 输入：root = [1,null,2] 输出：[1,2]
提示：
树中节点数目在范围 [0, 100] 内
-100 <= Node.val <= 100
题目地址
做题思路
1、递归：
递归三要素：确定方法的参数和返回值、确定中止条件、确定单层逻辑
2、统一迭代
使用栈的数据结构，即前序遍历以右左中顺序入栈，中序遍历以右中左顺序入栈，后序遍历以中右左顺序入栈。由于二叉树永远都从根节点开始遍历，因此在实现中序遍历的时候会出现先访问节点（即经过了节点）但却不处理节点（即将节点放入最终数组），因此采用null对已经访问过却不处理的根节点进行标记
解题
递归解法
class Solution {
public List<Integer> preorderTraversal(TreeNode root) {
List<Integer> list = new ArrayList<>();
preorder(root,list);
return list;
}
//递归的实现，确定方法的参数和返回值
public void preorder(TreeNode root,List list){
//确定递归的终止条件
if(root == null){return;}
//确定单层递归逻辑
list.add(root.val);
//进行左节点递归
preorder(root.left,list);
//进行右节点递归
preorder(root.right,list);
}
}
迭代解法
class Solution {
public List<Integer> preorderTraversal(TreeNode root) {
List<Integer> list = new ArrayList<>();
//创建一个栈,要注意其类型为TreeNode
Stack<TreeNode> stack = new Stack<>();
//二叉树从根节点开始遍历，先把根节点放进栈里面
if(root != null){stack.push(root);}
while(!stack.isEmpty()){
//获取根节点，这样后续才能找出根节点的左右节点
TreeNode node = stack.peek();
if(node != null){
//在弹出该根节点，因为前序遍历以右左中顺序入栈
stack.pop();
if(root.right != null){
stack.push(root.right);
}
if(root.left != null){
stack.push(root.left);
}
//加入根节点，用null进行标记
stack.push(root);
stack.push(null);
}else{
//若是有null标记的节点，则说明访问过且需要加入数组
//把null弹出
stack.pop();
//获取根节点
Treenode node1 = stack.peek();
//弹出根节点
stack.pop();
list.add(node1.val);
}
}
return list;
}
}
`
解答代码存在的疑问
迭代算法为什么每个根节点后要加null？
由于访问节点和处理的节点不一致（所谓处理的节点就是根节点，因为每一种遍历的方式都是通过根节点来获取其左右节点的），因此无法同时解决访问节点（遍历节点）和处理节点（将元素放进结果集）不一致的情况。我们就将访问的节点放入栈中，把要处理的节点也放入栈中但是做标记。
** 递归该如何理解 **
递归相当于一棵树，不断往下走，不满足条件则往前回退，回退的是最近的那个元素。可用下图实现中序遍历进行理解
94.二叉树的中序遍历
给定一个二叉树的根节点 root ，返回 它的 中序 遍历 。
示例 1： 输入：root = [1,null,2,3] 输出：[1,3,2]
示例 2： 输入：root = [] 输出：[]
示例 3：
输入：root = [1] 输出：[1]
提示：
树中节点数目在范围 [0, 100] 内
-100 <= Node.val <= 100
做题思路
与前序遍历思路一致
解题
递归解法
class Solution {
public List<Integer> inorderTraversal(TreeNode root) {
List<Integer> list = new ArrayList<>();
inorder(root,list);
return list;
}
public void inorder(TreeNode node,List list){
//确定终止条件
if(node == null){
return;
}
inorder(node.left,list);
list.add(node.val);
inorder(node.right,list);
}
}
迭代解法
lass Solution {
public List<Integer> inorderTraversal(TreeNode root) {
List<Integer> list = new ArrayList<>();
Stack<TreeNode> stack = new Stack<>();
//将二叉树遍历的第一个根节点加入栈
if(root != null){
stack.push(root);
}
while(!stack.isEmpty()){
//获取根节点
TreeNode node = stack.peek();
//没有null标志说明该节点暂时不需要处理
if(node != null){
//弹出该节点
stack.pop();
if(root.right != null){
stack.push(root.right);
}
stack.push(node);
stack.push(null);
if(root.left != null){
stack.push(root.left);
}
}else{
//若是有null标记的节点，则说明访问过且需要加入数组
//把null弹出
stack.pop();
//获取根节点
TreeNode node1 = stack.peek();
//弹出根节点
stack.pop();
list.add(node1.val);
}
}
return list;
}
}
}
145.二叉树的后序遍历
做题思路
与前序遍历一样
解题
递归解法
class Solution {
public List<Integer> inorderTraversal(TreeNode root) {
List<Integer> list = new ArrayList<>();
postorder(root,list);
return list;
}
public void postorder(TreeNode node,List list){
//确定终止条件
if(node == null){
return;
}
postorder(node.left,list);
postorder(node.right,list);
list.add(node.val);
}
}
迭代解法
lass Solution {
public List<Integer> inorderTraversal(TreeNode root) {
List<Integer> list = new ArrayList<>();
Stack<TreeNode> stack = new Stack<>();
//将二叉树遍历的第一个根节点加入栈
if(root != null){
stack.push(root);
}
while(!stack.isEmpty()){
//获取根节点
TreeNode node = stack.peek();
//没有null标志说明该节点暂时不需要处理
if(node != null){
//弹出该节点
stack.pop();
stack.push(node);
stack.push(null);
if(root.right != null){
stack.push(root.right);
}
if(root.left != null){
stack.push(root.left);
}
}else{
//若是有null标记的节点，则说明访问过且需要加入数组
//把null弹出
stack.pop();
//获取根节点
TreeNode node1 = stack.peek();
//弹出根节点
stack.pop();
list.add(node1.val);
}
}
return list;
}
}
}
102.二叉树的层序遍历
给你二叉树的根节点 root ，返回其节点值的 层序遍历 。 （即逐层地，从左到右访问所有节点）。
示例 1：
输入：root = [3,9,20,null,null,15,7] 输出：[[3],[9,20],[15,7]]
示例 2：
输入：root = [1] 输出：[[1]]
示例 3：
输入：root = [] 输出：[]
提示：
树中节点数目在范围 [0, 2000] 内
-1000 <= Node.val <= 1000
题目地址
做题思路
队列先进先出，符合一层一层遍历的逻辑，因此使用队列的结构进行递归或者迭代
解题
递归解法
class Solution {
List<List<Integer>> list = new ArrayList<>();
public List<List<Integer>> levelOrder(TreeNode root) {
levelOrder1(root,0);
return list;
}
public void levelOrder1(TreeNode node,int deep){
//确定终止条件
if(node == null){return;}
//确定当前是第几层
deep++;
if(list.size() < deep){
//若是当前队列的长度小于层数 则说明需要往队列里再次添加队列
List<Integer> onelist = new ArrayList<>();
list.add(onelist);
}
list.get(deep - 1).add(node.val);
levelOrder1(node.left,deep);
//deep会是之前的值
levelOrder1(node.right,deep);
}
}
迭代解法
class Solution {
List<List<Integer>> list = new ArrayList<>();
public List<Integer> preorderTraversal(TreeNode root) {
if (node == null) return;
Queue<TreeNode> que = new LinkedList<TreeNode>();
que.offer(node);
while (!que.isEmpty()) {
List<Integer> itemList = new ArrayList<Integer>();
int len = que.size();
while (len > 0) {
TreeNode tmpNode = que.poll();
itemList.add(tmpNode.val);
if (tmpNode.left != null) que.offer(tmpNode.left);
if (tmpNode.right != null) que.offer(tmpNode.right);
len--;
}
resList.add(itemList);
}
}
`
403
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
