算法通关村第七关——理解二叉树的遍历（白银）

于 2023-08-10 11:17:49 发布
阅读量206 收藏
点赞数 1
分类专栏： 数据结构 算法 文章标签： 算法 笔记 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Hai_Helloyou/article/details/132205528
版权

算法通关村第七关——理解二叉树的遍历（白银）

1. 二叉树递归遍历

1.1 二叉树的前序遍历

leetcode 144. 二叉树的前序遍历

递归算法的三个要素：

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

以下以前序遍历为例：

  1. 确定递归函数的参数和返回值：
public void preorder(TreeNode node, List<Integer> result)
  1. 确定终止条件：
// 终止条件：当前节点为空
if (node == null) {
	return;
}
  1. 确定单层递归的逻辑
// 处理当前层逻辑：将当前节点的值加入结果集
result.add(node.val);
        
// 递归调用左子树
preorder(node.left, result);
        
// 递归调用右子树
preorder(node.right, result);

最后的代码：

class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        // 调用递归函数进行前序遍历
        preorder(root, result);
        return result;
    }

    public void preorder(TreeNode node, List<Integer> result) {
        // 终止条件：当前节点为空
        if (node == null) {
            return;
        }
        
        // 处理当前层逻辑：将当前节点的值加入结果集
        result.add(node.val);
        
        // 递归调用左子树
        preorder(node.left, result);
        
        // 递归调用右子树
        preorder(node.right, result);
    }
}
1.2 二叉树的中序遍历

leetcode 94. 二叉树的中序遍历

同上可得：

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

    public void inorder(TreeNode root, List<Integer> list) {
        if (root == null) {
            return;
        }
        inorder(root.left, list);
        list.add(root.val);
        inorder(root.right, list);
    }
}
1.3 二叉树的后序遍历

leetcode 145. 二叉树的后序遍历

同上可得：

class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        postorder
    }
    public void postorder(TreeNode root, List<Integer> res){
        if(root == null){
            return;
        }
        postorder(root.left, res);
        postorder(root.right, res);
        res.add(root.val);
    }
}

2. 二叉树迭代遍历

学习可以参考：代码随想录——迭代遍历二叉树

1.1 二叉树的前序遍历

leetcode 144. 二叉树的前序遍历

前序遍历
首先我们应该创建一个 Stack 用来存放节点，首先我们想要打印根节点的数据，此时 Stack 里面的内容为空，所以我们优先将头结点加入 Stack，然后打印。

之后我们应该先打印左子树，然后右子树。所以先加入 Stack 的就是右子树，然后左子树。
此时你能得到的流程如下:

中序遍历流程图 
// 前序遍历顺序：中-左-右，入栈顺序：中-右-左
class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        if (root == null){
            return result;
        }
        Stack<TreeNode> stack = new Stack<>();
        stack.push(root);
        while (!stack.isEmpty()){
            TreeNode node = stack.pop();
            result.add(node.val);
            if (node.right != null){
                stack.push(node.right);
            }
            if (node.left != null){
                stack.push(node.left);
            }
        }
        return result;
    }
}
1.2二叉树的中序遍历

leetcode 94. 二叉树的中序遍历

// 中序遍历顺序: 左-中-右 入栈顺序： 左-右
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        if (root == null){
            return result;
        }
        Stack<TreeNode> stack = new Stack<>();
        TreeNode cur = root;
        while (cur != null || !stack.isEmpty()){
           if (cur != null){
               stack.push(cur);
               cur = cur.left;
           }else{
               cur = stack.pop();
               result.add(cur.val);
               cur = cur.right;
           }
        }
        return result;
    }
}
1.3 二叉树的后序遍历

leetcode 145. 二叉树的后序遍历

后序遍历就是前序遍历的翻转

class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        if (root == null){
            return result;
        }
        Stack<TreeNode> stack = new Stack<>();
        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;
    }
}

3. 统一迭代法

代码随想录：二叉树统一迭代法

统一迭代的方式，让前中后序三种遍历方式都一样，能够统一风格

  1. 创建一个空的结果集列表和一个栈。
  2. 如果根节点不为空，将根节点压入栈中。
  3. 当栈不为空时循环执行以下操作：
    • 取出栈顶节点，如果该节点不为空，继续执行下面的操作；否则跳转到第6步。
    • 将右子节点压入栈中（如果右子节点不为空）。
    • 将左子节点压入栈中（如果左子节点不为空）。
    • 将当前节点再次压入栈中，并将空节点压入栈中作为标记。
  4. 当遇到空节点时，取出栈顶节点并弹出空节点。
  5. 将取出的节点的值添加到结果集列表中。
  6. 返回结果集列表。

这个算法的时间复杂度是O(n)，其中n是二叉树的节点数。

前序遍历如下：

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(n	ode.val); // 加入到结果集
            }
        }
        return result;
    }
}

那么中序遍历就只需要修改中间那部分内容：

st.pop(); // 将该节点弹出，避免重复操作，下面再将右中左节点添加到栈中

if (node.right!=null) st.push(node.right);  // 添加右节点（空节点不入栈）

st.push(node);                          // 添加中节点
st.push(null); // 中节点访问过，但是还没有处理，加入空节点做为标记。

if (node.left!=null) st.push(node.left);    // 添加左节点（空节点不入栈）

后序遍历如下：

st.pop(); // 将该节点弹出，避免重复操作，下面再将右中左节点添加到栈中

st.push(node);                          // 添加中节点
st.push(null); // 中节点访问过，但是还没有处理，加入空节点做为标记。

if (node.right!=null) st.push(node.right);  // 添加右节点（空节点不入栈）

if (node.left!=null) st.push(node.left);    // 添加左节点（空节点不入栈）
XiaoZhi-paperfly
关注
专栏目录
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值