树-层序遍历的迭代写法

最新推荐文章于 2023-02-21 11:06:09 发布

sdusgq

最新推荐文章于 2023-02-21 11:06:09 发布

阅读量290

点赞数 1

分类专栏：数据结构与算法-树

本文链接：https://blog.csdn.net/sdusgq/article/details/111057320

版权

数据结构与算法-树专栏收录该内容

13 篇文章 0 订阅

订阅专栏

本文介绍了一种实现二叉树层序遍历的方法，采用队列来辅助完成遍历过程。首先创建一个队列并将根节点放入队列中，然后开始循环处理直到队列为空。每次循环都会处理当前层的所有节点，并将它们的值存入一个临时列表中，同时将下一层的节点加入队列。最后将每一层的节点值列表加入结果列表中。

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

一、代码实现

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;

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 List<List<Integer>> levelOrder(TreeNode root) {
//        List<List<Integer>> ret = new ArrayList<List<Integer>>();
//        if (root == null) {
//            return ret;
//        }
//
//        Queue<TreeNode> queue = new LinkedList<TreeNode>();
//        queue.offer(root);
//        while (!queue.isEmpty()) {
//            List<Integer> level = new ArrayList<Integer>();
//            int currentLevelSize = queue.size();
//            for (int i = 1; i <= currentLevelSize; ++i) {
//                TreeNode node = queue.poll();
//                level.add(node.val);
//                if (node.left != null) {
//                    queue.offer(node.left);
//                }
//                if (node.right != null) {
//                    queue.offer(node.right);
//                }
//            }
//            ret.add(level);
//        }
//
//        return ret;
//    }
//}

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {

        //思路 二叉树的层序遍历 通用思路为使用 队列，利用队列先进先出特点保存每一行的结点，遍历之后出队
        //时间复杂度 空间复杂度 O(n)
        List<List<Integer>> res = new ArrayList<>();

        if(root == null){
            return res;
        }
        //存储每层结点队列
        Queue<TreeNode> queueNodes = new LinkedList<>();
        //把当前根节点加入队列
        queueNodes.add(root);

        //遍历队列节点

        while(!queueNodes.isEmpty()){
            //获取当前层级有多少个节点
            int count = queueNodes.size();
            //保存当前遍历节点值得 list
            List<Integer> temp = new ArrayList<>();
            //根据队列中的数据 遍历获取节点值
            for (int i = 0; i < count; i++) {
                //当前节点是否有左右子节点
                if(queueNodes.peek().left !=null){
                    queueNodes.offer(queueNodes.peek().left);
                }
                if(queueNodes.peek().right !=null){
                    queueNodes.offer(queueNodes.peek().right);
                }
                //保存当前节点行元素值数组 并从队列中删除
                temp.add(queueNodes.poll().val);
            }
            //保存每一层节点数组
            res.add(temp);
        }

        return res;
    }
}

class test{
    public static void main(String[] args) {
        TreeNode node1 = new TreeNode(1);
        TreeNode node2 = new TreeNode(2);
        TreeNode node3 = new TreeNode(3);
        TreeNode node4 = new TreeNode(4);
        TreeNode node5 = new TreeNode(5);
        TreeNode node6 = new TreeNode(6);
        TreeNode node7 = new TreeNode(7);
        node1.left = node2;node1.right = node3;
        node2.left = node4;node2.right = node5;
        node3.left = node6;node3.right = node7;
        List<List<Integer>> res = new ArrayList<>();
        res = new Solution().levelOrder(node1);
        for (int i = 0; i < res.size(); i++) {
            System.out.println(res.get(i));
        }
    }
}