Bootstrap

【代码随想录训练营】【Day14】第六章｜二叉树｜理论基础｜递归遍历｜迭代遍历｜统一迭代

理论基础

二叉树的定义形式有：节点指针和数组

  • 在数组中，父节点的下标为i，那么其左孩子的下标即i*2+1，右孩子的下标即为i*2+2

二叉树的常见遍历形式有：前序遍历、后序遍历、中序遍历和层序遍历

  • 前序遍历：二叉树的节点遍历顺序为，根节点、左节点、右节点，常记为“根左右”
  • 同理后序遍历则为“左右根”，中序遍历则为“左根右”，其主要的区别在于“根节点”的遍历顺序
  • 但是注意，访问顺序和遍历顺序不是相同的概念，例如中序遍历应该理解为已访问过中节点，只是未处理它，需要优先处理它的左节点
  • 层序遍历：顾名思义，就是按照从根节点到叶节点、从左到右的顺序，一层一层地遍历节点

根据二叉树的定义不同，又可分为不同类型的二叉树，常见的有：

  • 满二叉树：只有度为0的结点和度为2的节点，并且度为0的结点都在同一层上。
  • 完全二叉树：整颗树（包括其每一棵子树）除了叶节点，其他每一个节点都有左右节点（节点不为空），同时要保证父子节点的顺序关系。
  • 二叉搜索树：整颗树（包括其每一棵子树）都满足左节点 < 父节点，右节点 > 父节点的条件，其中序遍历的结果为递增序列。
  • 二叉平衡树：整颗树（包括其每一棵子树）每一个节点都满足|其左右节点的树的高度的差值| <= 1

更多有关二叉树的理论基础可查阅：《代码随想录》二叉树理论基础

对于二叉树的遍历在《代码随想录》中都有非常详细的解释，我也是阅读学习之后再来解题的，所以在下面的解题过程中就不加以赘述了，仅贴出实现不同遍历形式的程序代码。

LeetCode.题目详细：

递归遍历二叉树

Java解法（递归，前序遍历）：

class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> ans = new ArrayList<>();
        this.preorder(root, ans);
        return ans;
    }

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

Java解法（递归，中序遍历）：

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

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

Java解法（递归，后序遍历）：

class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> ans = new ArrayList<>();
        this.postorder(root, ans);
        return ans;
    }

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

迭代遍历二叉树

Java解法（迭代，前序遍历）：

class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> ans = new ArrayList<>();
        this.preorder(root, ans);
        return ans;
    }

    public void preorder(TreeNode root, List<Integer> list){
        Stack<TreeNode> stack = new Stack<>();
        if(null != root) stack.push(root);
        while(!stack.isEmpty()){
            root = stack.pop();
            list.add(root.val);
            if(null != root.right) stack.push(root.right);
            if(null != root.left) stack.push(root.left);
        }
    }
}

Java解法（迭代，中序遍历）：

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

    public void inorder(TreeNode root, List<Integer> list){
        Stack<TreeNode> stack = new Stack<>();
        while(null != root || !stack.isEmpty()){
            if(null != root){
                stack.push(root);
                root = root.left;
            }else{
                root = stack.pop();
                list.add(root.val);
                root = root.right;
            }
        }
    }
}

Java解法（迭代，后序遍历）：

class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> ans = new ArrayList<>();
        this.postorder(root, ans);
        return ans;
    }

    public void postorder(TreeNode root, List<Integer> list){
        Stack<TreeNode> stack = new Stack<>();
        if(null != root) stack.push(root);
        while(!stack.isEmpty()){
            root = stack.pop();
            list.add(root.val);
            if(null != root.left) stack.push(root.left);
            if(null != root.right) stack.push(root.right);
        }
        Collections.reverse(list);
    }
}

我们发现迭代法实现的先中后序，其实风格也不是那么统一，除了先序和后序，有关联，中序完全就是另一个风格了，一会用栈遍历，一会又用指针来遍历。那么如何针对三种不同的遍历方式，使用迭代法是可以写出统一风格的代码？

统一迭代遍历二叉树【重点】

可以利用标记法来做到统一迭代：

  • 将访问的节点放入栈中，把要处理的节点也放入栈中但是要做标记。
  • 在这里，我们利用空指针来做标记，在要处理的节点放入栈之后，紧接着放入一个空指针作为标记。
  • 详细的解释和实现可以查阅：《代码随想录》二叉树的统一迭代法

Java解法（统一迭代，前序遍历）：

class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> ans = new ArrayList<>();
        this.preorder(root, ans);
        return ans;
    }

    public void preorder(TreeNode root, List<Integer> list){
        Stack<TreeNode> stack = new Stack<>();
        if(null != root) stack.push(root);
        while(!stack.isEmpty()){
            root = stack.peek();
            if(null != root){
                stack.pop(); // 需要先弹出节点，避免后续重复访问
                // 节点按照右左根的顺序进栈，后续出栈顺序为根左右（前序遍历）
                if(null != root.right) stack.push(root.right);
                if(null != root.left) stack.push(root.left);
                stack.push(root);
                stack.push(null); // 对需要处理的节点，在其后面跟上空指针作为标记
            }else{
                stack.pop(); // 遇到标记时，先弹出标记
                // 再弹出下一个节点进行处理
                root = stack.pop();
                list.add(root.val);
            }
        }
    }
}

Java解法（统一迭代，中序遍历）：

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

    public void inorder(TreeNode root, List<Integer> list){
        Stack<TreeNode> stack = new Stack<>();
        if(null != root) stack.push(root);
        while(!stack.isEmpty()){
            root = stack.peek();
            if(null != root){
                stack.pop(); // 需要先弹出节点，避免后续重复访问
                // 节点按照右根左的顺序进栈，后续出栈顺序为左根右（中序遍历）
                if(null != root.right) stack.push(root.right);
                stack.push(root);
                stack.push(null); // 对需要处理的节点，在其后面跟上空指针作为标记
                if(null != root.left) stack.push(root.left);
            }else{
                stack.pop(); // 遇到标记时，先弹出标记
                // 再弹出下一个节点进行处理
                root = stack.pop();
                list.add(root.val);
            }
        }
    }
}

Java解法（统一迭代，后序遍历）：

class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> ans = new ArrayList<>();
        this.postorder(root, ans);
        return ans;
    }

    public void postorder(TreeNode root, List<Integer> list){
        Stack<TreeNode> stack = new Stack<>();
        if(null != root) stack.push(root);
        while(!stack.isEmpty()){
            root = stack.peek();
            if(null != root){
                stack.pop();// 需要先弹出节点，避免后续重复访问
                // 节点按照根右左的顺序进栈，后续出栈顺序为左右根（后序遍历）
                stack.push(root);
                stack.push(null);// 对需要处理的节点，在其后面跟上空指针作为标记
                if(null != root.right) stack.push(root.right);
                if(null != root.left) stack.push(root.left);
            }else{
                stack.pop();// 遇到标记时，先弹出标记
                // 再弹出下一个节点进行处理
                root = stack.pop();
                list.add(root.val);
            }
        }
    }
}

二叉树结构也是在编程中常见的数据结构之一，例如堆其实就是一个树结构，以及哈希表中也运用到了红黑树来优化哈希表的存储结构等等。

通过今天的练习，我第一次了解并学习到了二叉树的统一迭代遍历算法，利用标记法来遍历二叉树的方法真的是非常巧妙，同时通过迭代算法的练习，也加深了对递归是如何模拟一个栈，以及递归算法如何转变为迭代算法有了一个初步的思路：

门径初窥书海奥, 欣喜若狂凯歌还。

悦读

道可道，非常道；名可名，非常名。 无名，天地之始，有名，万物之母。 故常无欲，以观其妙，常有欲，以观其徼。 此两者，同出而异名，同谓之玄，玄之又玄，众妙之门。

最新收录
《苍穹外卖》Day05部分知识点记录
代码随想录day4:454四数相加 383赎金信 15三数之和 18四数之和
spark conf、config配置项总结
Python中的__slots__：内存优化的利器
【剑指Offer】个人学习笔记_61_扑克牌中的顺子
redis常用数据结构解析 原创
C/C++---------------LeetCode第374. 猜数字大小
WIF调试分享（ap6256）
vue3 子组件中直接修改父组件传递过来的值
「AI绘画Stable Diffusion 零基础入门必看」ControlNet控制网：轻松控制你的AI绘画出图效果详解
;