二叉树遍历递归法迭代法实现

一.递归法实现二叉树遍历

前序遍历

创建一个节点类 属性是val,左节点,右节点

java 复制代码
public class TreeNode {  
    int val;  
    TreeNode left;  
    TreeNode right;  
    TreeNode(int x) { val = x; }  
}

前序遍历

java 复制代码
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);//递归遍历右子树
    }
}

中序遍历

java 复制代码
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);//递归遍历右子树
    }
}

后序遍历

java 复制代码
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); //处理中间结点
    }
}

二.迭代法实现

迭代法就是用栈结构模拟递归法的压栈出栈操作,实现对二叉树的前序后序中序遍历

1.前序遍历迭代法实现

前序遍历:中右左->中左右

中节点先加入结果res,然后先右后左入栈,出栈时先左后右,加入res,组成中左右

如果只有3个节点二叉树

中节点先进入栈,中节点弹出,中节点加入res,

中节点右孩子入栈,中节点左孩子入栈,此时栈里面是右左,数组里面只有一个中,出栈顺序就是左右,

出栈依次处理完毕加入数组就是中左右

举例说明

代码实现

java 复制代码
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;
    }
}

2.后序遍历迭代法实现

前序遍历程序顺序是中右左,结果集合是中左右:

前序遍历:中右左->中左右

如果把前序遍历程序中右左的左右颠倒 得到程序中左右

此时中左右此时结果集合应该是中右左

再对结果翻转得到左右中即为后序遍历

代码实现

java 复制代码
// 后序遍历顺序 左-右-中 入栈顺序:中-左-右 出栈顺序:中-右-左, 最后翻转结果
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.中序遍历迭代法实现

中序遍历的顺序是左中右

但是我们一开始遍历起点是中,所以我们要从中结点开始不断找左孩子,在这个过程中保存经过的值(必然是使用栈保存,先进后出)

元素为空时,回退,从栈里面弹出元素,向右走一步,

元素不为空时,元素入栈,向左走

具体分析如下

代码实现

java 复制代码
// 中序遍历顺序: 左-中-右 入栈顺序: 左-右
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;
    }
}

三.递归法迭代法总结

递归法和迭代法都可以实现对二叉树的遍历,但它们在实现方式、内存消耗和适用场景等方面存在差异。

递归法直观易懂,但可能受到栈空间的限制;

迭代法实现相对复杂,但更加高效且稳定。

在实际应用中,可以根据具体需求和场景选择合适的方法。

相关推荐
想跑步的小弱鸡3 小时前
Leetcode hot 100(day 3)
算法·leetcode·职场和发展
SsummerC10 小时前
【leetcode100】每日温度
数据结构·python·leetcode
jingshaoyou10 小时前
Strongswan linked_list_t链表 注释可独立运行测试
数据结构·链表·网络安全·list
Swift社区10 小时前
Swift LeetCode 246 题解:中心对称数(Strobogrammatic Number)
开发语言·leetcode·swift
对方正在长头发丿11 小时前
LETTERS(DFS)
c++·笔记·算法·深度优先·图论
逸狼13 小时前
【Java 优选算法】二分算法(下)
数据结构
云 无 心 以 出 岫16 小时前
贪心算法QwQ
数据结构·c++·算法·贪心算法
俏布斯16 小时前
算法日常记录
java·算法·leetcode
脑子慢且灵17 小时前
蓝桥杯冲刺:一维前缀和
算法·leetcode·职场和发展·蓝桥杯·动态规划·一维前缀和
姜威鱼17 小时前
蓝桥杯python编程每日刷题 day 21
数据结构·算法·蓝桥杯