二叉树节点的层级输出

更详细的讲解和代码调试演示过程，请参看视频
如何进入google,算法面试技能全面提高指南

二叉树节点的变量有三种方法，分别是前序遍历，中序遍历，后续遍历。如今，要求咱们实现算法，使得逐层将节点打印出来，例如开始先打印最高层，也就是节点5，而后打印第二层，也就是节点3， 7， 接着打印第三层，也便是节点1，4，6，8；最后打印最底层，也就是节点0， 2， 9.

这个问题处理不难，咱们依赖队列这个数据结构可方便实现这个功能。作法是，

1，  首先把根节点加入队列：

5

2， 接着把队列头结点的数值打印出来，把头结点的左右孩子加入队列

5->3->7

3,   去掉队列头结点，而后进入步骤2.

根据上面步骤，算法对节点的处理以下
list: 5
output: 5

list: 3->7
output: 3

list: 7->1->4
output: 7

list: 1->4->6->8
output: 1

list: 4->6->8->0->2
output: 4

list: 6->8->0->2
output: 6

list: 8->0->2
output: 8

list: 0->2->9
output: 0

list: 2->9
output: 2

list: 9
output: 9

对应的代码实现以下：

public class ListUtility {
    private Node tail;
    private Node head;
    private int listLen = 0;
    private int postingListLen = 0;
    HashMap<Integer, PostingNode> map = new HashMap<Integer, PostingNode>();
    TreeNode treeHead = null;

    public TreeNode createTree() {
        int[] a = new int[]{5,7,3,1,2,6,8,4,9,0};
        for (int i = 0; i < 10; i++) {
            insertTreeNode(a[i]);
        }

        return treeHead;
    }

    private void insertTreeNode(int val) {
        if (treeHead == null) {
            treeHead = new TreeNode();
            treeHead.val = val;
            treeHead.left = treeHead.right = null;
            return;
        }

        TreeNode node = treeHead;
        while (node != null) {
            if (node.val > val && node.left  != null) {
                node = node.left;
                continue;
            }

            if (node.val <= val && node.right != null) {
                node = node.right;
                continue;
            }

            TreeNode temp = new TreeNode();
            temp.val = val;
            temp.left = null;
            temp.right = null;

            if (node.val > val) {
                node.left = temp;
                break;
            } else {
                node.right = temp;
                break;
            }
        }
    }
...
}

在ListUtility中，经过createTree和insertTreeNode两个函数来构造排序二叉树。createTree会返回树的根节点。

层级打印的逻辑实如今类PrintTreeList:

import java.util.ArrayList;

public class PrintTreeList {
    private ArrayList<TreeNode> list = new ArrayList<TreeNode>();

    public PrintTreeList(TreeNode head) {
        if (head != null) {
            list.add(head);        
        }
    }

    public void printTree() {

        while (list.size() > 0) {
            TreeNode t = list.remove(0);
            System.out.print(t.val + " ");
            if (t.left != null) {
                list.add(t.left);
            }

            if (t.right != null) {
                list.add(t.right);
            }
        }
    }
}

它的作法正是将树节点依次加入队列，而后去除队列头的节点打印出来，同时把当前节点的左右子节点加入队列末尾。

因为算法须要遍历一次因此节点所以时间复杂度是O(n), 又由于须要为每一个树节点分配一个队列节点，所以空间复杂度是O(n).更详细的代码讲解和调试演示请参看视频。

本文分享自微信公众号 - Coding迪斯尼（gh_c9f933e7765d）。
若有侵权，请联系 support@oschina.cn 删除。
本文参与“OSC源创计划”，欢迎正在阅读的你也加入，一块儿分享。