网易：层次遍历二叉树

题目描述

分层遍历二叉树
用java实现树结构，分层遍历二叉树。给定一棵二叉树，要求按分层遍历该二叉树，即从上到下按层次访问该二叉树（每一层单独输出一行），每一层要求访问的顺序为从左到右，再按照相同规则从下至上遍历一遍，树节点定义如下
class Node {
int data;
Node left;
Node right;
}
输入描述
图：
        __1__
       /         __2__     3__
   /     \         4     __5__     6
       7     8
上面的输入为：1, 2, 3, 4, 5, 0, 6, 0, 0, 7, 8注：0代表这个位置没有数字，数据长度不超过1024。
输出描述
按照层级正向和反向输出二叉树，注意输出行末没有空格
示例1
输入
1, 2, 3, 4, 5, 0, 6, 0, 0, 7, 8
输出
1
2 3
4 5 6
7 8

7 8
4 5 6
2 3
1

代码

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
import java.util.Scanner;
class Node{
    int val;
    Node left;
    Node right;
    public Node(int val){
        this.val = val;
    }
}
public class A1 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String[] str = sc.nextLine().split(",");
        int len = str.length;
        int[] data = new int[len];
        for(int i=0; i<len; i++){
            data[i] = Integer.valueOf(str[i]);
        }
        Node root = creat(data);
        List<List<Integer>> result = levelorder(root);
        for (int i = 0; i < result.size(); i++) {
            for (int j = 0; j < result.get(i).size(); j++) {
                System.out.print(result.get(i).get(j) + " ");
            }
            System.out.println();
        }
        System.out.println();
        for (int i = result.size()-1; i >= 0; i--) {
            for (int j = 0; j < result.get(i).size(); j++) {
                System.out.print(result.get(i).get(j) + " ");
            }
            System.out.println();
        }
    }
    public static Node creat(int[] objs){
        ArrayList<Node> datas =new ArrayList<Node>();
        //        将一个数组的值依次转换为Node节点
        for(int o:objs){
            datas.add(new Node(o));
        }
        //第一个数为根节点
        Node root=datas.get(0);
        //建立二叉树
        for (int i = 0; i <objs.length/2; i++) {
            //左孩子
            if(datas.get(i*2+1).val!=0){
                datas.get(i).left=datas.get(i*2+1);
            }
            //右孩子
            if((i*2+2)<datas.size() && datas.get(i*2+2).val!=0){//避免偶数的时候 下标越界
                datas.get(i).right=datas.get(i*2+2);
            }
        }
        return root;
    }

    public static List<List<Integer>> levelorder(Node Node) {
        Queue<Node> queue = new LinkedList<>();
        List<List<Integer>> result = new ArrayList<>();
        queue.offer(Node); // 首先将根节点root入队
        while (!queue.isEmpty()) {// Queue不为空则循环
            List<Integer> node = new ArrayList<>();// 保存每一层节点的值
            int length = queue.size();// 每一层的节点数目
            while (length > 0) {
                Node tree = queue.poll();
                if (tree.left != null) {
                    queue.offer(tree.left);
                }
                if (tree.right != null) {
                    queue.offer(tree.right);
                }
                node.add(tree.val);
                length--;
            }
            // 循环结束后，得到的Queue为下一层做准备，node为本层遍历结果
            result.add(node);
        }
        return result;
    }
}

原文地址：https://www.cnblogs.com/haimishasha/p/11370583.html