二叉树的遍历

给定一个二叉树，返回其按层次遍历的节点值。（即逐层地，从左到右访问所有节点）。

例如:
给定二叉树: [3,9,20,null,null,15,7],

返回其层次遍历结果：

[
  [3],
  [9,20],
  [15,7]
]

一开始的解法是，先层次遍历把所有的树节点存放进一个二维List中，然后在做一次嵌套循环将每个节点的值存放进另一个二维list中

public List<List<Integer>> levelOrder(TreeNode root) {
        //层次遍历的结果数组
        List<List<Integer>> arrayLists=new ArrayList<List<Integer>>();

        if(root==null){
            return arrayLists;
        }



        //基本情况判断
        if(root.left==null&&root.right==null){
            List<Integer> temps=new ArrayList<>();
            temps.add(root.val);
            arrayLists.add(temps);
            return arrayLists;
        }

        //存放树节点的二维list
        ArrayList<ArrayList<TreeNode>> arrays=new ArrayList<>();

        //二维list中的每一行
        ArrayList<TreeNode> temp=new ArrayList<>();
        temp.add(root);
        arrays.add(temp);

        //层数
        int level=0;
        //层次遍历节点
        while(arrays.get(level).size()!=0){

            temp=arrays.get(level);
            ArrayList<TreeNode> cur=new ArrayList<>();
            for(int i=0;i< temp.size();i++){

                if(temp.get(i).left!=null){
                    cur.add(temp.get(i).left);
                }

                if(temp.get(i).right!=null){
                    cur.add(temp.get(i).right);
                }

            }
            if(cur.size()!=0) {
                arrays.add(cur);
                level++;
            }else{
                break;
            }

        }

        //生成层次遍历的数组
        for (int i = 0; i < arrays.size(); i++) {
            ArrayList<TreeNode> tempTreeNode=arrays.get(i);
            List<Integer>  resultTemp=new ArrayList<>();

            for (int j = 0; j <tempTreeNode.size(); j++) {
                resultTemp.add(tempTreeNode.get(j).val);
            }

            arrayLists.add(resultTemp);
        }


        return arrayLists;
    }

但是这样代码一看就很丑，而且感觉做了很多不必要的工作

看了别人的解法，学习到了

层次遍历其实就是一个队列，按照从上到下，从左到右的顺序进行处理

所以处理的方法就是：将当前节点的值存放进二维List中，并且将其左右子节点依次存放进queue中（如果存在的话）

并用一个变量length标识当前层的数量，用于作为分段。

length初始值为1，因为根节点只有一个

处理完一层厚，length=queue.size(); （因为处理节点时，采用poll（)方法，会将改节点移出队列，所以每一层的所有节点处理完后，queue中只有其所有的子节点）

public List<List<Integer>> levelOrder2(TreeNode root) {
        List<List<Integer>> resultList=new ArrayList<>();

        if(root==null){
            return resultList;
        }

        Queue<TreeNode> cur=new LinkedList<>();
        cur.offer(root);

        int length=1;

        List<Integer> t=new ArrayList<>();

        while(!cur.isEmpty()){
            TreeNode tem=cur.poll();
            t.add(tem.val);
            length--;

            if(tem.left!=null){
                cur.offer(tem.left);
            }

            if(tem.right!=null){
                cur.offer(tem.right);
            }

            if(length==0){
                resultList.add(t);
                t=new ArrayList<>();
                length=cur.size();
            }

        }

        return resultList;
    }

[LeetCode]初级算法-树-二叉树的层次遍历

二叉树的遍历

猜你喜欢