二叉树系列1: 层次遍历二叉树

要求：从根节点开始，从上到下，从左到右逐层打印二叉树的节点。

方法1

TreeNode.java

package BinaryTree;

public class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;

    public TreeNode(TreeNode l, TreeNode r, int v) {
        left = l;
        right = r;
        val = v;
    }

    public TreeNode(int v) {
        val = v;
    }

}

BinaryTreeTest.java

package BinaryTree;

import java.util.LinkedList;

public class BinaryTreeTest {

    public void LevelorderTraversal(TreeNode root) {
        if (root == null) {
            return;
        }

        LinkedList<TreeNode> queue = new LinkedList<>();
        int parentCount = 1;
        int childrenCount = 0;
        queue.add(root);
        TreeNode p;

        while (!queue.isEmpty()) {
            p = queue.removeFirst();
            System.out.printf("%-4d", p.val);
            parentCount--;
            if (p.left != null) {
                queue.add(p.left);
                childrenCount++;
            }
            if (p.right != null) {
                queue.add(p.right);
                childrenCount++;
            }

            if (parentCount == 0) {
                System.out.println();
                parentCount = childrenCount;
                childrenCount = 0;
            }
        }
    }

}

Main.java

package BinaryTree;

public class Main {

    public static void main(String[] args) {
        /***
         * 新建一个二叉树：
         * 
         *            15
         *           /  \
         *          12   25
         *         / \
         *        9   13
         * ***/
        TreeNode root = new TreeNode(15);
        TreeNode l = new TreeNode(12);
        root.left = l;
        TreeNode r = new TreeNode(25);
        root.right = r;
        TreeNode ll = new TreeNode(9);
        TreeNode lr = new TreeNode(13);
        l.left = ll;
        l.right = lr;

        BinaryTreeTest bTreeTest = new BinaryTreeTest();
        bTreeTest.LevelorderTraversal(root);

    }

}

---

---

方法二

上面的方法是利用了队列进行比较严谨地层次遍历。然而如果只是要得到每一层的节点，有另一种实现方法，可以使用任何的遍历次序，只要遍历的同时记录节点的层次关系就行了。下面的示例代码就是使用前序遍历输出层次遍历的结果。

import java.util.ArrayList;

public class Test2 {
    public ArrayList<ArrayList<TreeNode>> createLevelLinkedList(TreeNode root) {
        ArrayList<ArrayList<TreeNode>> lists = new ArrayList<>();
        createLevelLinkedList(root,lists, 0);
        return lists;
    }

    /**
     * TreeNode root：子树的根节点
     * lists： 保存每个层级的链表
     * int level： 当前的层级
     * */
    private void createLevelLinkedList(TreeNode root, ArrayList<ArrayList<TreeNode>> lists, int level) {
        if(root == null){
            return;
        }
        // 当前需要添加的那一层的链表
        ArrayList<TreeNode> currLevelList;

        // 如果level大于等于lists的size，说明这一层的节点是首次访问到，所以需要新建一个链表
        if(level >= lists.size()){
            currLevelList = new ArrayList<>();
            lists.add(currLevelList);
        }else{
            // 否则，直接获取已存在的链表
            currLevelList = lists.get(level);
        }

        // 采用先序遍历
        currLevelList.add(root);
        createLevelLinkedList(root.left, lists, level+1);
        createLevelLinkedList(root.right, lists, level+1);
    }
}

测试

    public static void main(String[] args) {
        Test2 test = new Test2();
        /***
         * 新建一个二叉树：
         * 
         *            15
         *           /  \
         *          12   25
         *         / \
         *        9   13
         * ***/
        TreeNode root = new TreeNode(15);
        TreeNode l = new TreeNode(12);
        root.left = l;
        TreeNode r = new TreeNode(25);
        root.right = r;
        TreeNode ll = new TreeNode(9);
        TreeNode lr = new TreeNode(13);
        l.left = ll;
        l.right = lr;
        ArrayList<ArrayList<TreeNode>> lists = test.createLevelLinkedList(root);
        for (ArrayList<TreeNode> arrayList : lists) {
            for (TreeNode treeNode : arrayList) {
                System.out.printf("%-4d",treeNode.val);
            }
            System.out.println();
        }
    }

输出

15  
12  25  
9   13