【二叉树专题】—— 遍历二叉树

LeetCode 144: 二叉树的前序遍历

在这里插入图片描述
📖 解题思路:

(1)二叉树的前序遍历:

重复子问题: 根结点 左子树 右子树
递归结束条件: 当前结点为空

(2)此题需要一个List集合来维护遍历过的结点的值

  • ArrayList 与 LinkedList 的区别:

两者都实现了List的接口,前者的底层是数组,后者的底层是链表
前者便于查找,时间复杂度为O(1);后者便于添加和删除,但后者需要更多的存储空间

📝 Java递归版本:

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    //设计一个方法,来完成前序遍历与结点值的记录
    public  void preorder(TreeNode root, ArrayList res){
        //如果当前结果为空,那么直接返回空
        if(root == null){
            return;
        }

        res.add(root.val);

        //递归左子树
        preorder(root.left, res);
        //递归右子树
        preorder(root.right, res);

    }

    public List<Integer> preorderTraversal(TreeNode root) {
        /**
            前序遍历属于自顶向下的遍历,递归部分:根结点 左子树 右子树
            递归结束条件:当前结点值为空
            返回值为一个集合,也就是要将结点的元素值添加到集合中

            输出错误分析:
                因为我采用的是递归遍历二叉树,但是没有把递归的算法分离出来,
                这样在没次进入新结点时,都会创建一个新的集合,这样就导致集
                合中只保存了一个值

            PS:
                (1)ArrayList与LinkedList的区别:
                    两者都实现类List接口,但是前者的底层实现原理是数组,
                    后者的实现原理是链表;
                    前者查询速度更快,后者插入删除操作更快;
                    后者每个结点存储两个引用,所以后者更占空间
         */

        //创建一个结合
        ArrayList<Integer> res = new ArrayList<Integer>();

        preorder(root, res);
        
        return res;
    }
}

📝 Java迭代版本:



LeetCode 94: 二叉树的中序遍历

在这里插入图片描述
⭕️ 解题思路:

大体部分与前序遍历类似,再添加元素到集合中时,先遍历左子树再添加元素即可

Java递归版本:

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    //定义一个方法来完成中序遍历
    public void inorder(TreeNode root, ArrayList res){
        
        
        if(root == null){
            return;
        }
        //递归左子树
        inorder(root.left, res);
        //将结点值添加到集合中
        res.add(root.val);
        //递归右子树
        inorder(root.right, res);


    }
    public List<Integer> inorderTraversal(TreeNode root) {
        //创建一个集合
        ArrayList<Integer> res = new ArrayList<Integer>();

        //调用中序遍历的方法
        inorder(root, res);

        return res;
    }
}

LeetCode 145: 二叉树的后序遍历

在这里插入图片描述
🅰️ 解题思路:

与前序和中序类似,最后处理根结点

🅱️ Java递归版本:

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }    
 */
class Solution {
    public void postorder(TreeNode root, ArrayList res){
        if(root == null){
            return;
        }
        postorder(root.left,res);
        postorder(root.right, res);     
        res.add(root.val);
    }
    public List<Integer> postorderTraversal(TreeNode root) {
        ArrayList<Integer> res = new ArrayList<Integer>();

        postorder(root, res);

        return res;
    }
}

LeetCode 102: 二叉树的层次遍历

在这里插入图片描述
📖 解题思路:

(1)通过给出的算法模板我们可以知道,返回的是一个大集合里包含多个小集合。由此我们可以得知,对于每一个子集合存储着每一层的元素。

(2)通过设置索引来为结点找到应该添加到哪个集合中。

(3)对于层次遍历的顺序是从左到右的,所以我们选择先递归左子树再递归右子树

☎️ Java递归版本:

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public void level(TreeNode root, int index, List<List<Integer>> result){
        //如果结点为空
        if(root == null){
            return;
        }
        //如果当前集合的大小小于树的深度,说明需要创建一个新的子集合
        if(result.size() < index){
            result.add(new ArrayList<Integer>()); 
        }
        //将当前结点值添加到该层的集合中
        result.get(index - 1).add(root.val);
        //因为层次遍历的顺序是从左向右,所以应该先递归左子树再递归右子树
        if(root.left != null){
            level(root.left, index + 1, result);
        }
        if(root.right != null){
            level(root.right, index + 1, result);
        }

    }
    public List<List<Integer>> levelOrder(TreeNode root) {
        //如果根结点为空,返回指定类型的集合
        if(root == null){
            return new ArrayList<List<Integer>>();
        }
        //创建一个结果集合
        List<List<Integer>> result = new ArrayList<List<Integer>>();
        //调用层序遍历递归算法
        level(root, 1, result);
        //返回
        return result;
    }
}
  • 1
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
二叉树的层序遍历是一种逐层地从左到右访问所有节点的方法。在Java中,可以使用递归或队列来实现二叉树的层序遍历。 递归方法的实现如下所示: ```java public List<List<String>> levelOrder(Tree root) { List<List<String>> list = new ArrayList<>(); levelOrderHelper(root, list, 0); return list; } public void levelOrderHelper(Tree root, List<List<String>> list, int level) { if (root == null) { return; } if (level >= list.size()) { list.add(new ArrayList<>()); } list.get(level).add(root.val); levelOrderHelper(root.left, list, level + 1); levelOrderHelper(root.right, list, level + 1); } ``` 另一种方法是使用队列来实现,具体代码如下所示: ```java public List<List<Integer>> levelOrder(TreeNode root) { List<List<Integer>> result = new ArrayList<>(); if (root == null) { return result; } Queue<TreeNode> queue = new LinkedList<>(); queue.add(root); while (!queue.isEmpty()) { int len = queue.size(); List<Integer> list = new ArrayList<>(); while (len > 0) { TreeNode node = queue.poll(); list.add(node.val); if (node.left != null) { queue.add(node.left); } if (node.right != null) { queue.add(node.right); } len--; } result.add(list); } return result; } ``` 以上是二叉树的层序遍历的两种Java实现方法。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* [Java:实现二叉树的层次遍历](https://blog.csdn.net/qq_45000317/article/details/123143184)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v92^chatsearchT3_1"}}] [.reference_item style="max-width: 50%"] - *2* *3* [二叉树层序遍历——java](https://blog.csdn.net/weixin_50616848/article/details/124769746)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v92^chatsearchT3_1"}}] [.reference_item style="max-width: 50%"] [ .reference_list ]

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Bow.贾斯汀

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值