最全二叉树的遍历方式总结

最新推荐文章于 2022-10-10 12:31:29 发布
最新推荐文章于 2022-10-10 12:31:29 发布
阅读量122 收藏 3
点赞数 3
分类专栏： leetcode总结 文章标签： 二叉树 队列 stack queue dfs
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/e935052319/article/details/117221113
版权

本文囊括了二叉树遍历的所有方式，基本所有二叉树的题目中，都要基于本文的实现，进行改造和升级。
推荐扔进收藏吃灰

文章目录

最全二叉树的遍历方式总结

一、前序遍历

1、递归实现

不加说明后面树节点的定义方式都为：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */

这里参看 leetcode 144. 二叉树的前序遍历

题目描述：给你二叉树的根节点 root ，返回它节点值的 前序 遍历。

class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        preOrder(root, res);
        return res;
    }

    public void preOrder(TreeNode node, List res) {
        if (node == null) return ;
        res.add(node.val);	// 访问
        preOrder(node.left, res);	// 左
        preOrder(node.right, res);	// 右
    }
}

2、迭代实现

方法一： 模仿递归实现的思路

class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        if (root == null) return res;
        Stack<TreeNode> stack = new Stack<>();
        stack.push(root);
        while (!stack.isEmpty()) {
            TreeNode node = stack.pop();
          	// 因为利用栈进行遍历的时候是从栈顶部进行弹出
          	// 所以要想实现先左后右的访问必须先将右节点入栈
            if (node != null) {
                res.add(node.val);	// 访问
                stack.push(node.right);	// 右
                stack.push(node.left);	// 左
            }
        }
        return res;
    }
}

方法二： 栈的回溯的思路

class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        Deque<TreeNode> stk = new LinkedList<>();
      	// 判空
        while (root != null || !stk.isEmpty()) {
          	// 先遍历至没有左节点，过程中不断压栈
            while (root != null) {
                // 访问节点
                res.add(root.val);
                stk.push(root);
                root = root.left;
            }
          	// 没有左节点后，弹出
        		// 此时弹出的为最左节点
            root = stk.pop();
          	
          	// 无左节点后压入右节点，继续循环
            root = root.right;
        }
        return res;
    }
}

二、中序遍历

1、递归实现

leetcode 94.二叉树的中序遍历

题目描述：给你二叉树的根节点 root ，返回它节点值的 中序 遍历。

class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        inOrder(root, res);
        return res;
    }

    public void inOrder(TreeNode node, List res) {
        if (node == null) return;
        inOrder(node.left, res);
        res.add(node.val);
        inOrder(node.right, res);
        
    }
}

2、迭代实现

这里要注意区别于前序遍历，我们不能简单的再次调转前序遍历中的顺序就实现了。

详细见代码注释

class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        Deque<TreeNode> stk = new LinkedList<>();
      	// 判空
        while (root != null || !stk.isEmpty()) {
          	// 先遍历至没有左节点，过程中不断压栈
            while (root != null) {
                stk.push(root);
                root = root.left;
            }
          	// 没有左节点后，弹出
        		// 此时弹出的为最左节点
            root = stk.pop();
          	// 访问节点
            res.add(root.val);
          	// 无左节点后压入右节点，继续循环： 左->左->左...访问->
            root = root.right;
        }
        return res;
    }
}

三、后序遍历

1、递归实现

leetcode 145. 二叉树的后序遍历

题目描述：给你二叉树的根节点 root ，返回它节点值的 后序 遍历。

class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        postOrder(root, res);
        return res;
    }

    public void postOrder(TreeNode node, List res) {
        if (node == null) return;
        postOrder(node.left, res);
        postOrder(node.right, res);
        res.add(node.val);
    }
}

2、迭代实现

后序遍历较于前序和中序要稍稍复杂一点点，我们需要维护一个指针来判断当前节点是否为 三次访问过的节点（包括叶子节点）

这里定义一个概念方便我们去理解，在访问一个节点时，需要经历这种步骤如下：

第一次抵达->遍历左孩子->第二次抵达->遍历右孩子->第三次抵达->弹出（不再访问）

此时我们定义这个不在访问到的节点为无效节点

class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();							
        Deque<TreeNode> stack = new LinkedList<TreeNode>();				
        TreeNode prev = null;																			// new
        while (root != null || !stack.isEmpty()) {
            while (root != null) {
                stack.push(root);
                root = root.left;
            }
          	// 弹出叶子节点或无效节点的父节点
            root = stack.pop();
          	// 判断是否将要成为无效节点
          	// 右孩子为空或者为prev说明，右孩子是无效节点，即将弹栈，节点将成为无效节点
            if (root.right == null || root.right == prev) {
              	// 成为无效节点前进行访问
                res.add(root.val);
              	// 访问后标记无效节点
                prev = root;
              	// 置空，表示无效节点，并准备下次循环弹栈
                root = null;
            } else {
                stack.push(root);
                root = root.right;
            }
        }
        return res;
    }
}

四、迭代法统一的代码风格（*）

下面的方法摘自代码随想录大佬。

1、前序

class Solution {
  
  public List<Integer> preorderTraversal(TreeNode root) {
      List<Integer> result = new LinkedList<>();
      Stack<TreeNode> st = new Stack<>();
      if (root != null) st.push(root);
      while (!st.empty()) {
          TreeNode node = st.peek();
          if (node != null) {
              st.pop(); // 将该节点弹出，避免重复操作，下面再将右中左节点添加到栈中
              if (node.right!=null) st.push(node.right);  // 添加右节点（空节点不入栈）
              if (node.left!=null) st.push(node.left);    // 添加左节点（空节点不入栈）
              st.push(node);                          // 添加中节点
              st.push(null); // 中节点访问过，但是还没有处理，加入空节点做为标记。
              
          } else { // 只有遇到空节点的时候，才将下一个节点放进结果集
              st.pop();           // 将空节点弹出
              node = st.peek();    // 重新取出栈中元素
              st.pop();
              result.add(node.val); // 加入到结果集
          }
      }
      return result;
  }
}

2、中序

class Solution {
  public List<Integer> inorderTraversal(TreeNode root) {
  	    List<Integer> result = new LinkedList<>();
      Stack<TreeNode> st = new Stack<>();
      if (root != null) st.push(root);
      while (!st.empty()) {
          TreeNode node = st.peek();
          if (node != null) {
              st.pop(); // 将该节点弹出，避免重复操作，下面再将右中左节点添加到栈中
              if (node.right!=null) st.push(node.right);  // 添加右节点（空节点不入栈）
              st.push(node);                          // 添加中节点
              st.push(null); // 中节点访问过，但是还没有处理，加入空节点做为标记。

              if (node.left!=null) st.push(node.left);    // 添加左节点（空节点不入栈）
          } else { // 只有遇到空节点的时候，才将下一个节点放进结果集
              st.pop();           // 将空节点弹出
              node = st.peek();    // 重新取出栈中元素
              st.pop();
              result.add(node.val); // 加入到结果集
          }
      }
      return result;
  }
}

3、后序

class Solution {

 public List<Integer> postorderTraversal(TreeNode root) {
      List<Integer> result = new LinkedList<>();
      Stack<TreeNode> st = new Stack<>();
      if (root != null) st.push(root);
      while (!st.empty()) {
          TreeNode node = st.peek();
          if (node != null) {
              st.pop(); // 将该节点弹出，避免重复操作，下面再将右中左节点添加到栈中
              st.push(node);                          // 添加中节点
              st.push(null); // 中节点访问过，但是还没有处理，加入空节点做为标记。
              if (node.right!=null) st.push(node.right);  // 添加右节点（空节点不入栈）
              if (node.left!=null) st.push(node.left);    // 添加左节点（空节点不入栈）         
                             
          } else { // 只有遇到空节点的时候，才将下一个节点放进结果集
              st.pop();           // 将空节点弹出
              node = st.peek();    // 重新取出栈中元素
              st.pop();
              result.add(node.val); // 加入到结果集
          }
      }
      return result;
 }
}

五、层序遍历（一通万通的板子）

1、基础的层序遍历

  • leetcode 102. 二叉树的层序遍历

在这里插入图片描述

题目描述：

给你一个二叉树，请你返回其按 层序遍历 得到的节点值。 （即逐层地，从左到右访问所有节点）。

这里我们写一个层序遍历的板子

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        Deque<TreeNode> queue = new LinkedList<>();
        List<List<Integer>> res = new ArrayList<>();
        if (root == null) return res;
        queue.offer(root);
      	// 队列不为空
        while (!queue.isEmpty()) {
            List<Integer> level = new ArrayList<>();
          	// 当前队列的容量即为当前层数节点的容量
            int currentSize = queue.size();
          	// 遍历当前层
          	// 循环结束后，队列的 前面部分为当前层的节点，此时已经全部弹出
          	// 然后在循环遍历时在队列后面已经加入了下一层的全部节点
            for (int i = 0; i < currentSize; i ++) {
              	// 弹出遍历过的节点
                TreeNode node = queue.poll();
              	// 将弹出的节点值进行记录
                level.add(node.val);
              	// 将左孩子加入队列
                if (node.left != null) {
                    queue.offer(node.left);
                }
              	// 将右孩子加入队列
                if (node.right != null) {
                    queue.offer(node.right);
                }
            }
            res.add(level);
        }
        return res;
    }
}

2、从下到上的层序遍历

  • leetcode 107. 二叉树的层序遍历 II
    在这里插入图片描述

解题思路：

根据上面已经写过的层序遍历，我们只需要在遍历的时候将下一层的结果插入上一层的结果之前就可以了，详情看代码变动的部分。

class Solution {
    public List<List<Integer>> levelOrderBottom(TreeNode root) {
        List<List<Integer>> res = new ArrayList<>();
        if (root == null) return res;
        Deque<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()) {
            int currentSize = queue.size();
            List<Integer> level = new ArrayList<>();
            for (int i = 0; i < currentSize; i ++) {
                TreeNode node = queue.poll();
                level.add(node.val);
                if (node.left != null) {
                    queue.offer(node.left);
                }
                if (node.right != null) {
                    queue.offer(node.right);
                }
            }
            res.add(0, level); // 只需要在这里调整一下插入的位置就可以
        }
        return res;
    }
}

3、二叉树的右视图

  • leetcode 199. 二叉树的右视图

在这里插入图片描述

解题思路：

依然是二叉树的层序遍历，只不过我们这次只需要存储每一层中最后一个节点的值就可以了。

详细看代码标注的位置

class Solution {
    public List<Integer> rightSideView(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        if (root == null) return res;
        Deque<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()) {
            int currentSize = queue.size();
            TreeNode node = root;		// 这里要将变量拿出来以便循环外访问， 并设置第一层的时候默认为root节点
            for (int i = 0; i < currentSize; i ++) {
                node = queue.poll();	// 没有变化，依然是遍历queue的时候存储，在循环结束后为当前层的最后一个节点
                if (node.left != null) {
                    queue.offer(node.left);
                }
                if (node.right != null) {
                    queue.offer(node.right);
                }
            }
            res.add(node.val);	// 将最后一个节点的值加入结果集中
        }
        return res;
    }
}

4、二叉树的层平均值

  • leetcode 637. 二叉树的层平均值

在这里插入图片描述

因为太简单了，直接把我们的板子粘过来。

class Solution {
    public List<Double> averageOfLevels(TreeNode root) {
        Deque<TreeNode> queue = new LinkedList<>();
        List<Double> res = new ArrayList<>();
        if (root == null) return res;
        queue.offer(root);
      	// 队列不为空
        while (!queue.isEmpty()) {
            List<Integer> level = new ArrayList<>();
          	// 当前队列的容量即为当前层数节点的容量
            int currentSize = queue.size();
            double sum = 0;
          	// 遍历当前层
          	// 循环结束后，队列的 前面部分为当前层的节点，此时已经全部弹出
          	// 然后在循环遍历时在队列后面已经加入了下一层的全部节点
            for (int i = 0; i < currentSize; i ++) {
              	// 弹出遍历过的节点
                TreeNode node = queue.poll();
              	// 将弹出的节点值进行记录
                sum += node.val;
              	// 将左孩子加入队列
                if (node.left != null) {
                    queue.offer(node.left);
                }
              	// 将右孩子加入队列
                if (node.right != null) {
                    queue.offer(node.right);
                }
            }
            res.add(sum / currentSize);
        }
        return res;
    }
}

5、n叉树的层序遍历

  • leetcode 429. n叉树的层序遍历

在这里插入图片描述

解题思路：

和二叉树的层序遍历是一个思路，只不过在遍历孩子节点的时候是通过List来访问的。

详细见下面代码标注的部分。

class Solution {
    public List<List<Integer>> levelOrder(Node root) {
        List<List<Integer>> res = new ArrayList<>();
        if (root == null) return res;
        Deque<Node> queue = new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()) {
            int currentSize = queue.size();
            List<Integer> level = new ArrayList<>();
            for (int i = 0; i < currentSize; i ++) {
                Node node = queue.poll();
                level.add(node.val);
              	// 这里在访问孩子节点的时候通过 list for的形式进行遍历即可
                for (Node subNode : node.children) {
                    queue.offer(subNode);
                }
            }
            res.add(level);
        }
        return res;
    }
}
/*
// Definition for a Node.
class Node {
    public int val;
    public List<Node> children;

    public Node() {}

    public Node(int _val) {
        val = _val;
    }

    public Node(int _val, List<Node> _children) {
        val = _val;
        children = _children;
    }
};
*/

6、在每层树找最大值

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

在这里插入图片描述

解题思路：

依然是太简单，粘板子

class Solution {
    public List<Integer> largestValues(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        if (root == null) return res;
        Deque<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()) {
            int currentSize = queue.size();
            int max = Integer.MIN_VALUE; // 这里用来记录最大值
            for (int i = 0; i < currentSize; i ++) {
                TreeNode node = queue.poll();
                max = Math.max(max, node.val);
                if (node.left != null) {
                    queue.offer(node.left);
                }
                if (node.right != null) {
                    queue.offer(node.right);
                }
            }
            res.add(max); // 将每一层记录的最大值记录进结果集
        }
        return res;
    }
}

7、填充每个节点的下一个右侧指针

在这里插入图片描述
在这里插入图片描述

上板子，随便改改：

class Solution {
    public Node connect(Node root) {
        if (root == null) return null;
        Deque<Node> queue = new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()) {
            int currentSize = queue.size();
            for (int i = 0; i < currentSize; i ++) {
                Node node = queue.poll();
              	// 只需要在这里变更一下是否是最后一个节点，不是就链接到下一个节点
                if (i < currentSize - 1) {
                    node.next = queue.peek();
                }
                if (node.left != null) {
                    queue.offer(node.left);
                }
                if (node.right != null) {
                    queue.offer(node.right);
                }
            }
        }
        return root;
    }
}
深林无鹿
关注
  • 3
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉树大总结1_二叉树的各种题(遍历、查找)
12-09
二叉树大总结1_二叉树的各种题(遍历、查找等)，是网上一个不错的学习例子。
迭代法 c++ 实现 二叉树的前序遍历，后续遍历，中序遍历
samoyan的博客,记录技术成长~
02-23 169
vector<int> preorderTraversal(TreeNode* root) { vector<int> res; stack<TreeNode*> st; TreeNode *p = root; while(p|| !st.empty()) { while(p) { res.push_back(p->val); st.push(p.
二叉树遍历总结
weixin_43928720的博客
07-22 80
1 中序遍历 （1）递归 public static void indiSort(TreeNode head) { if (head == null) { return; } indiSort(head.left); System.out.println(head.val); indiSort(head.right); } (2) 非递归 ...
二叉树的遍历总结
ITSOK_123的博客
05-02 1044
二叉树的遍历1.前序遍历1.1 递归前序1.2 利用栈模拟递归2.3 迭代3.后序遍历3.1 递归3.2 迭代3.3 直接迭代保存 二叉树节点结构如下 struct TreeNode { int val; TreeNode *left; TreeNode *right; TreeNode() : val(0), left(nullptr), right(nullptr) {} TreeNode(int x) : val(x), left(nul
二叉树遍历问题 关于二叉树遍历问题的一些总结
最新发布
07-05
二叉树遍历问题 ⼀、⼆叉树的重要性 很多经典算法如 回溯、⼴度优先遍历、分治、动态规划等通常需要转化为树的问题，⽽树的题⽬难免涉及到递归的问题，因此掌握树的三 种遍历框架是必须的。 　先序遍历：根，左，右 ...
二叉树遍历问题，总结递归和迭代解法
11-29
二叉树遍历问题，从「前序」、「中序」、「后序」、「层序」四种遍历⽅式出发，总结他们的递归和迭代解法。同时包含代码的案例分析，内容比较详实，可供参考。
二叉树遍历实验报告
01-09
实现了二叉树的前中后遍历，以及层次遍历，求出了二叉树的深度，叶子个数。 实验报告还包含目录，所有遍历方法的解释，以及结果展示和结论改进
关于软考-二叉树遍历问题总结前序遍历、后序遍历、中序遍历、递归遍历
04-24
常见的二叉树遍历，分为前序、中序、后续和层次遍历4种。 层次遍历相对比较好理解，对于前3种遍历方式概念的记忆方式应该是这样的：左和右的顺序始终是固定的—先左后右，所谓的前序、中序和后序是针对根来说的。...
二叉树遍历
05-22
二叉树遍历 采用二叉链表存储结构 含有数据域 左指针域 右指针域 前序遍历： ABDEFCG 后序遍历： GCFEDBA 中序遍历2： DBFEAGC 层序遍历： ABCDEGF 树高： 4 位置为10处路径0为左孩子1为右孩子： 010 总结点数： 7
二叉树的实现各种遍历算法
09-29
二叉树的实现各种遍历算法，插入删除成员函数非常全。二叉树的实现各种遍历算法，插入删除成员函数非常全
二叉树遍历的总结
Key Board的博客
06-15 1780
二叉树是一棵树，其中每个节点都不能有多于两个的孩子。 理解二叉树的遍历可以帮助我们很好地理解递归以及栈。在前端的应用中也或多或少地会接触到树的遍历和操作(DOM树以及当前热门框架的各种diff算法)， 除此之外，在数据库中建立索引，高效的查找也是得益于二叉搜索树这种特殊的数据结构。其基本思想都是大同小异。 因此，掌握二叉搜索树的相关的遍历算法是一个合格工程师基本的技能。 对于二叉树的遍历，根据根节点的访问顺序，可以被分为先序遍历、中序遍历以及后序遍历。 作为广度优先搜索思想的体现，层次遍历(补充在最后)也需
二叉树及二叉树遍历总结
csyifanZhang的博客
04-19 460
文章目录二叉树及二叉树遍历完全二叉树二叉树的遍历前序遍历中序遍历后序遍历遍历的性质 二叉树及二叉树遍历 完全二叉树 对于一棵具有n个节点的二叉树（按层序编号），如果编号为i的节点与同样深度的满二叉树中编号为i的节点在二叉树的位置完全相同，则为完全二叉树。完全二叉树是线段树的基础，他独特的编号方式使得其可以不依赖于指针进行操作。 左边二叉树按照完全二叉树进行编号，出现了10号的空挡，右边二叉树出现...
二叉树及遍历总结
WHY380012801的博客
08-27 277
前言 由于最近一直在忙目标检测这块的项目，一直没有时间静下心来总结经典算法之一：二叉树。下面我会给大家介绍二叉树的定义以及其应用，方便大家加深对该算法的理解。 1. 二叉树 二叉树是一种特殊的树，它具有以下特点： 1.树中每个节点最多只能有两棵树，即每个节点的度最多为2。    2.二叉树的子树有左右之分，即左子树与右子树，次序不能颠倒。    3.二叉树即使只有一个子树时，...
二叉树的遍历方法总结
11-04 428
文章目录前言结构定义概述前序递归迭代中序递归迭代后序递归迭代基于中序迭代基于翻转的迭代前、中、后序迭代的统一解决方法层次迭代 前言 之前写了一篇文章记录二叉树的迭代遍历，最近在刷树的题目，有必要再重新整理一下，之前用C++描述，这次改为用Python描述 注：本文没有囊括所有遍历方法，本文只记录作者平常使用的遍历方法 结构定义 # Definition for a binary tree node. class TreeNode: def __init__(self, val=0, left=No
二叉树的四种遍历总结
weixin_57003452的博客
05-18 1020
二叉树的遍历方式有四种：前、中、后序遍历，以及层次遍历 递归解法： 层次遍历的递归解法并不是主流，我们仅介绍前三种方式的递归解法。它们的模版相对来说比较固定，一般都会新增一个函数： def dfs(root): if not root: return res.append(root.val) # 前序遍历 dfs(root.left) dfs(root.right) 对于前中后序遍历，仅需将递归函数里的放在不同的位置即
【二叉树遍历方法大总结（全注释）—Leetcode刷题方法汇总】
Kakakawhi的博客
10-10 1023
【二叉树遍历方法大总结（全注释）—Leetcode刷题方法汇总】
《剑指offer》面试题：二叉树的遍历总结
qq_43502142的博客
03-07 445
二叉树的遍历总结

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值