二叉树系列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();

4000
}
}

输出

15
12  25
9   13