對於二叉樹一般是按深度生成和遍歷，比如使用遞迴方法進行先序遍歷、中序遍歷、後序遍歷。這次我們按層次生成和遍歷二叉樹。

這種遍歷方式關鍵在於需要使用一個佇列儲存“已處理該節點，但還沒處理它的子節點”這樣的節點。

# Python程式碼

# Definition for singly-linked list.
class BinTree(object):
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None

class Solution(object)
 
:

    # 按層次建立二叉樹
    def createBinTree(self, inputList):

        # 尚未設定子節點的節點列表
        nodeList = []

        if (inputList == None) or (len(inputList) == 0):
            return None
        # 取出根元素
        value = inputList.pop(0)
        root = BinTree(value)
        nodeList.append(root)

        # 結束條件：所有值不為“#”的節點都設定了子節點，即nodeList為空
 

        while len(nodeList) != 0:
            leftValue = inputList.pop(0)
            rightValue = inputList.pop(0)
            if leftValue != '#' and rightValue != '#':
                nodeLeft = BinTree(leftValue)
                nodeRight = BinTree(rightValue)

                # 每次取出兩個節點，加入到 “未設定子節點的節點列表”
 

                nodeList.append(nodeLeft)
                nodeList.append(nodeRight)
                nodeList[0].left = nodeLeft
                nodeList[0].right = nodeRight

                # 為節點設定子節點後移出佇列
                nodeList.pop(0)

            # 若值為#，不需要處理，預設情況下節點的左右節點都為None
            elif leftValue == '#' and rightValue != '#':
                nodeRight = BinTree(rightValue)
                nodeList.append(nodeRight)
                nodeList[0].right = nodeRight
                nodeList.pop(0)
            elif rightValue == '#' and leftValue != '#':
                nodeLeft = BinTree(leftValue)
                nodeList.append(nodeLeft)
                nodeList[0].left = nodeLeft
                nodeList.pop(0)
            else:
                nodeList.pop(0)
        return root

    # 按層次遍歷二叉樹
    def traverseBinTree(self, root):
        nodeList = []

        # 先將根節點加入佇列中
        if root != None:
            nodeList.append(root)
        while len(nodeList) != 0:

            # 輸出佇列第一個節點值，並將該節點的左右子節點加入佇列
            node = nodeList.pop(0)
            if node == None:
                print('#')
                continue
            print(node.val)

            leftNode = node.left
            rightNode = node.right

            nodeList.append(leftNode)
            nodeList.append(rightNode)



s = Solution()
root = s.createBinTree(inputList = ['A', 'B', 'C', '#', 'D', '#', 'E', 'F', '#', '#', '#', '#', '#'])
s.traverseBinTree(root)

再進一步，不僅要按層次遍歷二叉樹，還要將每一層分別放在一個列表中。[ [3], [9,20], [15,7] ]，實現這個要求重點在於確定何時一層遍歷完成。每層二叉樹的節點數目（含null節點）為上一層不含null節點的數目 * 2。可以採用兩個變數，記錄本層應該有多少個節點、和已經遍歷到多少個節點。二者相等時，本層節點遍歷結束。

// Java程式碼

import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

public class Solution {
    public List<List<Integer>> levelOrderBottom(TreeNode root) {
        List<List<Integer>> resultList = new ArrayList<>();

        // 記錄待遍歷的節點，每次取出隊首元素，並將其子節點（如果有）新增到佇列中。
        // 當nodeList為空時，所有節點遍歷結束
        List<TreeNode> nodeList = new ArrayList<>();

        // 記錄二叉樹每一層的節點
        List<Integer> layerList = new ArrayList<>();

        // 本層應該有多少個節點
        int eachLineNodeNum = 1;

        // 已經遍歷到多少個節點
        int currentNodeNum = 0;

        // 本層有多少個空節點
        int nullNodeNum = 0;

        if (root != null)
            nodeList.add(root);
        while (nodeList.size() != 0) {
            TreeNode node = nodeList.remove(0);
            if (node == null) {
                nullNodeNum ++;

                currentNodeNum++;

                if (eachLineNodeNum == currentNodeNum) {

                    // 下一層的節點數應為本層非空節點數 *2
                    eachLineNodeNum = (eachLineNodeNum - nullNodeNum) * 2;
                    currentNodeNum = 0;
                    nullNodeNum = 0;
//                  System.out.println("一層結束");

                    // 將layerList複製一份。
                    // 否則由於"引用傳遞"的特點，執行layerList.clear()時也會將resultList中的結果清除
                    if (layerList.size() != 0) {
                        resultList.add(new ArrayList<Integer>(layerList));
                        layerList.clear();
                    }

                }
                continue;
            }
            layerList.add(node.val);
            currentNodeNum++;
            if (eachLineNodeNum == currentNodeNum) {
                eachLineNodeNum = (eachLineNodeNum - nullNodeNum) * 2;
                currentNodeNum = 0;
                nullNodeNum = 0;
//              System.out.println("一層結束");
                if (layerList.size() != 0) {
                    resultList.add(new ArrayList<Integer>(layerList));
                    layerList.clear();
                }
            }

            TreeNode leftNode = node.left;
            TreeNode rightNode = node.right;

            nodeList.add(leftNode);
            nodeList.add(rightNode);
        }

        Collections.reverse(resultList);
        return resultList;
    }
}