二叉树的遍历

Yoin.

已于 2023-10-14 11:03:36 修改

阅读量27

点赞数

分类专栏：算法 Java 文章标签：算法数据结构

于 2022-12-24 15:02:55 首次发布

本文链接：https://blog.csdn.net/qq_39484271/article/details/128428522

版权

算法同时被 2 个专栏收录

23 篇文章 4 订阅

订阅专栏

Java

7 篇文章 2 订阅

订阅专栏

前序遍历：

二叉树的前序遍历的记忆法则是“根左右"，即先遍历根节点，再遍历左子树节点，再遍历右子树节点。

以上图为例，前序遍历的结果是【A, B, D, E, C, F, G】

一、解题思路：递归

递归是我们实现前中后序遍历最常用的方法。

什么问题可以采用递归求解呢？

需要满足三个条件：

一个问题的解可以分解为若干个子问题的解；
这个问题与分解的子问题，除了数据规模不同外，求解思路相同
存在递归终止条件。
那么在知道一个问题可以采用递归实现之后，如何写出递归代码呢？

关键在于能写出递归公式，找到终止条件。

在二叉树的前序遍历问题上，它的递归公式是:

preorder(node) = print node —> preorder(node->left) --> preorder(node->right)

它的终止条件是：

node 是否为空，为空则返回。

public static void preorder(TreeNode root,List<Integer> list){
        if(root==null) return ;
        list.add(root.val);
        preorder(root.left,list);
        preorder(root.right,list);
    }

二、解题思路：迭代

在递归方法实现过程中，它的底层是基于系统栈的结构来实现的。因此，我们可以使用栈的数据结构来辅助实现基于迭代方式的前序遍历。

具体思路为：

初始化栈stack，初始化输出列表res
根节点入栈
while(栈不为空)，在循环体内部：
- 栈顶元素出栈
- 栈顶元素添加到输出列表
- 如果栈顶元素的右子树节点不为空，将右子树节点入栈
- 如果栈顶元素的左子树节点不为空，将左子树节点入栈
返回输出列表res

public static List<Integer> preorderstack(TreeNode root){
        List<Integer> list = new ArrayList<Integer>();
        if (root==null) return list;
        Stack<TreeNode> stack = new Stack<TreeNode>();
        stack.push(root);
        while(!stack.isEmpty()){
            TreeNode node = stack.pop();
            list.add(node.val);
            if(node.right!=null){
                stack.push(node.right);
            }
            if (node.left!=null){
                stack.push(node.left);
            }
        }
        return list;
    }

中序遍历

二叉树的中序遍历的记忆法则是“左根右"，即先遍历左子树节点，再遍历根节点，再遍历右子树节点。

以上图为例，中序遍历的结果是【D, B, E, A, F, C, G】

一、解题思路：递归

递归是我们实现前中后序遍历最常用的方法。

什么问题可以采用递归求解呢？

需要满足三个条件：

一个问题的解可以分解为若干个子问题的解；
这个问题与分解的子问题，除了数据规模不同外，求解思路相同
存在递归终止条件。
那么在知道一个问题可以采用递归实现之后，如何写出递归代码呢？

关键在于能写出递归公式，找到终止条件。

在二叉树的中序遍历问题上，它的递归公式是:

preorder(node) = preorder(node->left) --> print node —> preorder(node->right)

它的终止条件是：

node 是否为空，为空则返回。

    public static void inorder(TreeNode root,List<Integer> list){
        if(root==null) return ;
        inorder(root.left,list);
        list.add(root.val);
        inorder(root.right,list);
    }

二、解题思路：迭代

基于迭代方法的思路如下：

初始化栈stack，初始化输出列表res
设置一个变量cur, 表示当前节点。并赋初始值为根节点root
while(栈不为空或者当前节点cur不为空)，在循环体内部：
- 沿着当前节点的左分支一直走，直到为空。在这个过程中将遍历的节点都入栈
- 栈顶元素出栈，同时将栈顶元素添加到输出列表
- 更新当前节点cur为栈顶元素的右子树节点。
返回输出列表res

初始时，当前节点cur = root ，即节点A

public static List<Integer> inorderstack(TreeNode root){
        List<Integer> list = new ArrayList<Integer>();
        if (root==null) return list;
        Stack<TreeNode> stack = new Stack<TreeNode>();
        while(root!=null || !stack.isEmpty()){
            while(root!=null){
                stack.push(root);
                root=root.left;
            }
            if (!stack.isEmpty()){
                root=stack.pop();
                list.add(root.val);
                root=root.right;
            }
        }
        return list;
    }

后序遍历

二叉树的后序遍历的记忆法则是“左右根"，即先遍历左子树节点，再遍历右子树节点，最后遍历根节点。

以上图为例，后序遍历的结果是【D, E, B, F, G, C, A】

一、解题思路：递归

递归是我们实现前中后序遍历最常用的方法。

什么问题可以采用递归求解呢？

需要满足三个条件：

一个问题的解可以分解为若干个子问题的解；
这个问题与分解的子问题，除了数据规模不同外，求解思路相同
存在递归终止条件。
那么在知道一个问题可以采用递归实现之后，如何写出递归代码呢？

关键在于能写出递归公式，找到终止条件。

在二叉树的前序遍历问题上，它的递归公式是:

preorder(node) = preorder(node->left) --> preorder(node->right) —> print node

它的终止条件是：

node 是否为空，为空则返回。

    public static List<Integer> postorder(TreeNode root, List<Integer> result){
        if (root==null) return result;
        postorder(root.left,result);
        postorder(root.right,result);
        result.add(root.val);
        return result;
    }

二、解题思路：迭代

我们在使用迭代法来实现后序遍历的时候，通常有两大类思路。第一类是先得到“根右左”，然后对输出列表反序，即得到“左右根”；第二类是直接求出“左右根”。

咱们知道，前序遍历是求“根左右”，那么我们可以使用前序遍历的方法，去求得“根右左”。以上图为例，我们求得的“根右左”的结果是【A, C, G, F, B, E, D】。再对这个结果反序，得到【D, E, B, F, G, C, A】。这正是咱们想得到的后序遍历。

在递归方法实现过程中，它的底层是基于系统栈的结构来实现的。因此，我们可以使用栈的数据结构来辅助实现基于迭代方式的后序遍历。

具体思路为：

初始化栈stack，初始化输出列表res
根节点入栈
while(栈不为空)，在循环体内部：
- 栈顶元素出栈
- 栈顶元素添加到输出列表
- 如果栈顶元素的左子树节点不为空，将左子树节点入栈
- 如果栈顶元素的右子树节点不为空，将右子树节点入栈
对输出列表res 进行反序
返回输出列表res

public static List<Integer> postorderstack(TreeNode root){
        List<Integer> result = new ArrayList<Integer>();
        if (root==null) return result;
        Stack<TreeNode> stack = new Stack<TreeNode>();
        stack.push(root);
        while(!stack.isEmpty()){
            TreeNode node = stack.pop();
            result.add(node.val);
            if (node.left!=null) stack.push(node.left);
            if (node.right!=null) stack.push(node.right);
        }
        Collections.reverse(result);
        return result;
    }

层序遍历

解法一：广度优先搜索BFS

广度优先搜索是从树的根节点开始，沿着树的宽度来遍历树的节点。如果所有节点均被访问，则算法中止。广度优先搜索通常采用队列来辅助实现。

广度优先搜索BFS：利用队列，将每个节点存入队列，再遍历当前节点是就把对应的孩子节点存入队列，依次即可。

在题目中要求按照层序遍历，实现逐层地从左向右访问所有的结点。这正好符合广度优先搜索的策略。

public static List<List<Integer>> bfs(TreeNode root) {
        List<List<Integer>> resultList = new ArrayList<List<Integer>>();
        Queue<TreeNode> queue = new LinkedList<>();
        if (root==null) return new ArrayList<>();
        //根节点入队
        queue.add(root);
        while(!queue.isEmpty()){
            int size=queue.size();//每层的节点个数
            //存每一层
            List<Integer> list =new ArrayList<>();
            for(int i=0; i<size; i++){
                TreeNode node = queue.poll();
                list.add(node.val);
                //若当前节点含有左右子树就将其加入队列，便于下一层的遍历
                if (node.left!=null){ queue.add(node.left); }
                if (node.right!=null){ queue.add(node.right);}
            }
            //加入这一层的节点
            resultList.add(list);
        }
        return resultList;
    }

解法二：深度优先搜索DFS

深度优先搜索DFS：采用递归的思想，从根节点(0层)进入，并且将根节点存入res，若level≥res的长度，说明要进入下一层，首先从当前节点的左子树来获取下层左部分的数据，从当前节点的右子树来获取下层右部分的数据，依次下去。

public static List<List<Integer>> levelorder(TreeNode root){
        List<List<Integer>> resultList = new ArrayList<List<Integer>>();
        dfs(root, resultList,0);//根节点、返回数组、遍历层数
        return resultList;

    }

    public static void dfs(TreeNode root, List<List<Integer>> resultList, int level) {
        if (root==null) return;
        //level 表示遍历的层数，若level大于resultList的当前长度，说明到了下一层。
        if (level>=resultList.size()){
            resultList.add(new ArrayList<>());//为新的一层创建数组
        }
        resultList.get(level).add(root.val);//把节点数据存入该层
        //如果当前节点有左右子树，从左右子树进入下一层，左子树进入该层的左半区，右子树进入该层右半区
        if (root.left!=null){dfs(root.left, resultList,level+1);}
        if (root.right!=null){dfs(root.right, resultList,level+1);}

    }

作者：Yoin
链接：https://leetcode.cn/problems/binary-tree-level-order-traversal/solutions/2031228/by-yoin_-5v2g/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。