打印二叉树第N层的数及层序遍历

例如：二叉树如图所示，现在想要求出第n层的元素有哪些？

代码：
思路：递归
从左子树一直延申（递归）到第N层的时候，将此元素存起来，再走右子树一直延申（递归）到第N层的时候，将元素存起来。

//获得第N层的元素
	static LinkedList<Node> list = new LinkedList();
    public static void showOfN(Node node, int n) {
        if (n == 1) {
            list.addLast(node);
            return;
        }
        if (node.left != null) {
            showOfN(node.left, n - 1);
        }
        if (node.right != null) {
            showOfN(node.right, n - 1);
        }

    }

完整代码及层序遍历代码：

注意：

showOfN是得到第N 层的结点
showCX是层序遍历，这个方法时间复杂度很高，因为递归求解有重叠的步骤
showCX2是层序遍历的优化版本

代码：

import java.util.ArrayList;
import java.util.LinkedList;

public class CengXu {
    static LinkedList<Node> list = new LinkedList();
    public static void main(String[] args) {
        Node node1 = new Node(1);
        Node node2 = new Node(2);
        Node node3 = new Node(3);
        Node node4 = new Node(4);
        Node node5 = new Node(5);
        Node node6 = new Node(6);
        Node node7 = new Node(7);

        node1.left = node2;
        node1.right = node3;
        //node2.left = node4;
        node2.right = node5;
        node3.left = node6;
        node3.right = node7;


        int n = 3;//第n层
        System.out.println("打印第n层的数");
        showOfN(node1,n);//打印第三层的数
        System.out.println(list);

        list=new LinkedList<>();//清空list
        System.out.println("\n层序遍历");
        showCX(node1);

        System.out.println("\n层序遍历优化");
        showCX2(node1);
    }

    //层序遍历优化
    public static void showCX2(Node node){
        LinkedList<Node> linkedList=new LinkedList<>();
        if (node==null){
            return;
        }
        linkedList.addLast(node);
       // System.out.println(node);
        while (!linkedList.isEmpty()){
            LinkedList<Node> nextLevels = new LinkedList<>();//存储当前的下一层的所有结点
            LinkedList<Node> currentResults = new LinkedList<>();//存储当前层的结点
            for (Node cur : linkedList) {
                currentResults.addLast(cur);
                if (cur.left!=null){
                    nextLevels.addLast(cur.left);
                }
                if (cur.right!=null){
                    nextLevels.addLast(cur.right);
                }
            }
            linkedList=nextLevels;//将当前层的下一层的结点给linkedList
            System.out.println(currentResults);//打印当前层
        }

    }


    //层序遍历递归形式，时间复杂度较高
    public static void showCX(Node root) {
        for (int i = 1; i <= 3; i++) {
            showOfN(root,i);
            System.out.println(list);
            list=new LinkedList<>();
        }
        //System.out.println(list);

    }

    //获得第N层的元素
    public static void showOfN(Node node, int n) {
        if (n == 1) {
            list.addLast(node);
            return;
        }
        if (node.left != null) {
            showOfN(node.left, n - 1);
        }
        if (node.right != null) {
            showOfN(node.right, n - 1);
        }

    }


}


class Node {
    int val;
    Node left;
    Node right;

    public Node(int val) {
        this.val = val;
    }

    @Override
    public String toString() {
        return "TreeNode3{" +
                "val=" + val +
                '}';
    }
}

结果：

打印第n层的数
[TreeNode3{val=5}, TreeNode3{val=6}, TreeNode3{val=7}]

层序遍历
[TreeNode3{val=1}]
[TreeNode3{val=2}, TreeNode3{val=3}]
[TreeNode3{val=5}, TreeNode3{val=6}, TreeNode3{val=7}]

层序遍历优化
[TreeNode3{val=1}]
[TreeNode3{val=2}, TreeNode3{val=3}]
[TreeNode3{val=5}, TreeNode3{val=6}, TreeNode3{val=7}]