代码随想录 - 二叉树的各种遍历方法（Java）

最新推荐文章于 2024-08-19 17:19:27 发布

溪溪1111

最新推荐文章于 2024-08-19 17:19:27 发布

阅读量1.1k

点赞数

分类专栏：算法学习文章标签： java 算法 leetcode

本文链接：https://blog.csdn.net/weixin_45685902/article/details/129820292

版权

算法学习专栏收录该内容

26 篇文章 0 订阅

订阅专栏

本文介绍了二叉树的两种主要遍历方式——深度优先和广度优先。深度优先包括前序、中序和后序遍历，通常使用递归和迭代两种方法实现。广度优先遍历则通过队列实现层次遍历。文章详细展示了各种遍历的递归和迭代代码实现，并强调了递归的三要素以及迭代过程中的访问与处理顺序问题。

摘要由CSDN通过智能技术生成

二叉树的遍历方式

方法

做二叉树相关题目，经常会使用递归的方式来实现深度优先遍历，也就是实现前中后序遍历，使用递归是比较方便的。之前讲栈与队列的时候，就说过栈其实就是递归的一种实现结构，也就说前中后序遍历的逻辑其实都是可以借助栈使用非递归的方式来实现的。

而广度优先遍历的实现一般使用队列来实现，这也是队列先进先出的特点所决定的，因为需要先进先出的结构，才能一层一层的来遍历二叉树。

一刷因为时间关系，选择各个问题最简单的方法来进行介绍。

二叉树的递归遍历

链接: 144.二叉树的前序遍历
链接: 145.二叉树的后序遍历
链接: 94.二叉树的中序遍历

引

本笔记将介绍前后中序的递归写法，通过简单题目把方法论确定下来，有了方法论，后面才能应付复杂的递归

递归三要素：

确定递归函数的参数和返回值：确定哪些参数是递归的过程中需要处理的，那么就在递归函数里加上这个参数，并且还要明确每次递归的返回值是什么进而确定递归函数的返回类型
**确定终止条件：**写完了递归算法，运行的时候，经常会遇到栈溢出的错误，就是没写终止条件或者终止条件写的不对，操作系统也是用一个栈的结构来保存每一层递归的信息，如果递归没有终止，操作系统的内存栈必然会溢出
**确定单层递归的逻辑：**确定每一层递归需要处理的信息。在这里也就会重复调用自己来实现递归的过程。

代码

// 前序遍历·递归·LC144_二叉树的前序遍历
class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<Integer>();
        preorder(root, result);
        return result;
    }

    public void preorder(TreeNode root, List<Integer> result) {
        if (root == null) {
            return;
        }
        result.add(root.val);
        preorder(root.left, result);
        preorder(root.right, result);
    }
}
// 中序遍历·递归·LC94_二叉树的中序遍历
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        inorder(root, res);
        return res;
    }

    void inorder(TreeNode root, List<Integer> list) {
        if (root == null) {
            return;
        }
        inorder(root.left, list);
        list.add(root.val);             // 注意这一句
        inorder(root.right, list);
    }
}
// 后序遍历·递归·LC145_二叉树的后序遍历
class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        postorder(root, res);
        return res;
    }

    void postorder(TreeNode root, List<Integer> list) {
        if (root == null) {
            return;
        }
        postorder(root.left, list);
        postorder(root.right, list);
        list.add(root.val);             // 注意这一句
    }
}

二叉树的迭代遍历

【卡哥代码随想录遍历问题整理得很好，此处在他的基础上进行笔记整理】
递归的实现就是：**每一次递归调用都会把函数的局部变量，参数值和返回地址等压入调用栈中，**然后递归返回的时候，从栈顶弹出上一次递归的各项参数，这就是递归为什么可以返回上一层位置的原因

前序遍历（迭代法）

前序遍历的顺序是中左右，每次先处理的是中间节点，那么先将根节点放入栈中，然后将右孩子加入栈，再加入左孩子

因为这样出栈的时候才会是中左右的顺序（出栈是倒序）

//前序遍历
class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> list = new ArrayList<>();
        Stack<TreeNode> st = new Stack<>();
        if (root == null) return list;
        st.push(root);
        while (!st.isEmpty()){
            TreeNode node = st.peek();
            st.pop();
            list.add(node.val);
            if (node.right != null){
                st.add(node.right);
            }
            if (node.left != null){
                st.add(node.left);
            }
        }
        return list;
    }
}

后序遍历（迭代法）

先序遍历是中左右，后续遍历是左右中，那么我们只需要调整一下先序遍历的代码顺序，就变成中右左的遍历顺序，然后在反转result数组，输出的结果顺序就是左右中了

联想能力，这个和字符串里面将后面几个单词移到前面是一样的道理。

class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> list = new ArrayList<>();
        Stack<TreeNode> st = new Stack<>();
        if (root == null) return list;
        st.push(root);
        while (!st.isEmpty()){
            TreeNode node = st.peek();
            st.pop();
            list.add(node.val);
             if (node.left != null){
                st.add(node.left);
            }
            if (node.right != null){
                st.add(node.right);
            }
        }
        // 返回值为void 
        // 有些函数的作用是改变传入参数的值
        // 不一定都需要返回值
        //PS 漏掉了s
        Collections.reverse(list);
        return list;
    }
}

中序遍历（迭代法）

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

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

分析一下为什么刚刚写的前序遍历的代码，不能和中序遍历通用呢，因为前序遍历的顺序是中左右，先访问的元素是中间节点，要处理的元素也是中间节点，所以刚刚才能写出相对简洁的代码，因为要访问的元素和要处理的元素顺序是一致的，都是中间节点。

那么再看看中序遍历，中序遍历是左中右，先访问的是二叉树顶部的节点，然后一层一层向下访问，直到到达树左面的最底部，再开始处理节点（也就是在把节点的数值放进result数组中），这就造成了处理顺序和访问顺序是不一致的。

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

class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> list = new ArrayList<>();
        Stack<TreeNode> st = new Stack<>();
        if (root == null) return list;
        TreeNode cur = root;
        while (cur != null || !st.isEmpty()){
            if (cur != null){
                st.push(cur);
                cur = cur.left;
            }else{
                // 当栈中元素弹出时，cur遍历退回后一位
                //不必再定义一个新节点接收
                cur = st.peek();
                st.pop();
                list.add(cur.val);
                cur = cur.right;
            }
        }
        return list;
    }
}

二叉树的统一迭代法

为了风格统一，设计了一种统一风格的代码

我们以中序遍历为例，在二叉树：听说递归能做的，栈也能做！ (opens new window)中提到说使用栈的话，无法同时解决访问节点（遍历节点）和处理节点（将元素放进结果集）不一致的情况。

【重点】那我们就将访问的节点放入栈中，把要处理的节点也放入栈中但是要做标记。

如何标记呢，就是要处理的节点放入栈之后，紧接着放入一个空指针作为标记。 这种方法也可以叫做标记法。

代码

//前序遍历，与入栈完全相反
//先将所有元素按中左右的倒序 右左中  完全入栈
//再设置条件出栈
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;
    }
}

//中序遍历
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;
}
}

//后序遍历
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;
   }
}

二叉树的层序遍历

需要借用一个辅助数据结构即队列来实现，队列先进先出，符合一层一层遍历的逻辑，而用栈先进后出适合模拟深度优先遍历也就是递归的逻辑。

代码

//迭代法
class Solution {
    List<List<Integer>> reList = new ArrayList<List<Integer>>();
    public List<List<Integer>> levelOrder(TreeNode root) {
        checkFun2(root);
        return reList;
    }
    void checkFun2(TreeNode root){
        if (root == null) return;
        Queue<TreeNode> que = new LinkedList<TreeNode>();
        que.offer(root);
        while (!que.isEmpty()){
            List<Integer> list = new ArrayList<>();
            int len = que.size();
            while (len > 0){
                TreeNode tempNode = que.poll();
                list.add(tempNode.val);

                //你以后还是别复制了，复制完总是忘了改东西
                if (tempNode.left != null) que.add(tempNode.left);
                if (tempNode.right != null) que.add(tempNode.right);
                len--;
            }
            reList.add(list);

        }
    }
}