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

Posted 2021-06-02 深林无鹿

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了最全二叉树的遍历方式总结相关的知识，希望对你有一定的参考价值。

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

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

一、前序遍历

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(以上是关于最全二叉树的遍历方式总结的主要内容，如果未能解决你的问题，请参考以下文章 
 二叉树的各种遍历方式，我都帮你总结了，附有队列堆栈图解
 算法总结你真的掌握了二叉树的遍历嘛
 同学，二叉树的各种遍历方式，我都帮你总结了，附有队列堆栈图解（巩固基础，强烈建议收藏）
 二叉树总结树的遍历
 二叉树的遍历（递归+迭代）
 二叉树的遍历（递归+迭代）

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

文章目录

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

一、前序遍历

1、递归实现

2、迭代实现

二、中序遍历

1、递归实现

2、迭代实现

三、后序遍历

1、递归实现

2、迭代实现

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

1、前序

2、中序

3、后序

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

1、基础的层序遍历

2、从下到上的层序遍历