Golang实现
/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 * Val int
 * Left *TreeNode
 * Right *TreeNode
 * }
 */
func levelOrder(root *TreeNode) [][]int {
    // return dfsLevelOrder(root)
    return bfsLevelOrder(root)
}

func bfsLevelOrder(root *TreeNode) [][]int {
    if root == nil {
        return [][]int{}
    }
    
    queue := make([]*TreeNode, 0)
    queue = append(queue, root)
    levels := make([][]int, 0)
    
    for len(queue) > 0 {
        
        n, level := len(queue), make([]int, 0)
        
        for i := 0; i < n; i++ {
            
            root = queue[0]
            queue = queue[1:]
            
            level = append(level, root.Val)
            
            if root.Left != nil {
                queue = append(queue, root.Left)
            }
            
            if root.Right != nil {
                queue = append(queue, root.Right)
            }
        }
        
        levels = append(levels, level)
    }
    
    return levels
}

func dfsLevelOrder(root *TreeNode) [][]int {
    level := 0
    vals := make([][]int, 0)
    dfs(root, level, &vals)
    return vals
}

func dfs(root *TreeNode, level int, vals *[][]int) {
    //fmt.Println(root, level, vals)
    if root == nil {
        return
    }
    
    if len(*vals) <= level {
        *vals = append(*vals, []int{root.Val})
    } else {
        (*vals)[level] = append((*vals)[level], root.Val)
    }
    
    dfs(root.Left, level+1, vals)
    dfs(root.Right, level+1, vals)
}

Golang实现的BFS，由于Golang中没有双端队列，因此使用两个数据来代替。
func levelOrder(root *TreeNode) [][]int {

    var result [][]int

    if root == nil {
        return result
    }

    var q = []*TreeNode{root}

    for len(q) > 0 {
        var current []int
        var p []*TreeNode
        for _, v := range q {
            current = append(current, v.Val)
            if v.Left != nil {
                p = append(p, v.Left)
            }
            if v.Right != nil {
                p = append(p, v.Right)
            }
        }
        result = append(result, current)
        q = p
    }

    return result
}

一个queue区分每层分界比较困难，那就用两个queue，每层元素交替放置在queue中

原创，C++：

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        if (root == NULL)
        {
            return (vector<vector<int>>)NULL;
        }

        this->q1->push(root);
        this->is_q1 = true;

        while (!this->q1->empty() || !this->q2->empty())
        {
            this->is_q1 ? this->doWork(this->q1, this->q2) : this->doWork(this->q2, this->q1);
        }

        return *(this->result);
    }
private:
    queue<TreeNode*> *q1 = new queue<TreeNode*>;
    queue<TreeNode*> *q2 = new queue<TreeNode*>;
    vector<int> *row = new vector<int>;
    vector<vector<int>> *result = new vector<vector<int>>;
    bool is_q1;

    void doWork(queue<TreeNode*> *pop, queue<TreeNode*> *push)
    {
        TreeNode *node = NULL;

        if (!pop->empty())
        {
            node = pop->front();
            if (node->left != NULL)
            {
                push->push(node->left);
            }
            if (node->right != NULL)
            {
                push->push(node->right);
            }
            this->row->push_back(node->val);
            pop->pop();
        }
        if (pop->empty())
        {
            this->result->push_back(*(this->row));
            this->row = new vector<int>;
            this->is_q1 = !this->is_q1;
        }
    }
};

PHP. 实现：
递归没写出来。
function levelOrder1($root)
    {
        if (!$root) return [];
        $res = [];
        $queue = []; // 定义队列 使用数组
        array_push($queue, $root); // 加入根节点
        $level = 0; // 队列里永远存在的是同一个级别的数据，所以要根据级别进行区分是那一层
        while ($queue) { // 只要队列有值就一只循环
            foreach ($queue as $value) {
                // 它的下一层如果有值的话，就要加入到队列中，
                if ($value->left != null) array_push($queue, $value->left);
                if ($value->right != null) array_push($queue, $value->right);
                // 当前队列中层是有值的，直接就加入进去；
                $res[$level][] = $value->val;
                // 这一层处理完了就要删除掉这一层的值
                array_shift($queue);
            }
            $level++;
        }
        return $res;
    }

没看到go语言版本的，分享一个go语言写的广度优先版本，抛砖引玉。由于go语言没有内置的队列，用单向列表实现了一个简单的队列。

package main

import (
    "fmt"
)

func main() {
    root := new(treeNode)
    vals := []int{1, 2, 3, 4, 5, 6, 7}
    createBST(vals, root)
    res := resolveLayers(root)
    fmt.Println(res)
}

// 二叉树节点
type treeNode struct {
    Val int
    Left *treeNode
    Right *treeNode
}

// 构造二叉搜索树
func createBST(vals []int, root *treeNode) {
    pos := len(vals) / 2
    root.Val = vals[pos]
    if pos > 0 {
        root.Left = &treeNode{}
        createBST(vals[:pos], root.Left)
    }
    if pos < len(vals)-1 {
        root.Right = &treeNode{}
        createBST(vals[pos+1:], root.Right)
    }
}

// 队列元素组成单向链表
type queueItem struct {
    Val interface{}
    Next *queueItem
}

// 通过持有队列的首尾元素和长度，更方面的进行入队和出队操作
type queue struct {
    Len int
    Head *queueItem
    Tail *queueItem
}

// 入队方法
func (q *queue) RightPush(item *queueItem) {
    if q.Head == nil || q.Tail == nil {
        q.Head = item
        q.Tail = item
    } else {
        q.Tail.Next = item
        q.Tail = item
    }
    q.Len++
}

// 出队方法
func (q *queue) LeftPop() *queueItem {
    if q.Len == 0 {
        return nil
    }
    item := q.Head
    q.Head = q.Head.Next
    if q.Head == nil {
        q.Tail = nil
    }
    q.Len--
    return item
}

// 分层输出二叉树的节点
func resolveLayers(root *treeNode) [][]int {
    q := new(queue)
    q.RightPush(&queueItem{Val: root})
    var res [][]int
    for q.Len != 0 {
        thisLen := q.Len
        var layerRes []int
        for i := 0; i < thisLen; i++ {
            node := q.LeftPop().Val.(*treeNode)
            layerRes = append(layerRes, node.Val)
            if node.Left != nil {
                q.RightPush(&queueItem{Val: node.Left})
                fmt.Println("left:", node.Left.Val)
            }
            if node.Right != nil {
                q.RightPush(&queueItem{Val: node.Right})
                fmt.Println("right:", node.Right.Val)
            }
        }
        res = append(res, layerRes)
    }
    return res
}

java dfs实现：

 /**
     * dfs实现
     *
     * @param root
     * @return
     */
    public List<List<Integer>> levelOrderDfs(TreeNode root) {
        List<List<Integer>> res = new ArrayList<>();
        if (root == null) return res;
        _dfs(res, root, 0);
        return res;
    }

    void _dfs(List<List<Integer>> res, TreeNode node, int level) {
        if (node == null) return;
        if (res.size() < level + 1) res.add(new ArrayList<>());
        res.get(level).add(node.val);
        _dfs(res, node.left, level + 1);
        _dfs(res, node.right, level + 1);
    }

DFS Solution
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 * int val;
 * TreeNode left;
 * TreeNode right;
 * TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> res = new ArrayList<>();
        levelHelper(res, root, 0);
        return res;
    }

    public void levelHelper(List<List<Integer>> res, TreeNode node, int level) {
        if (node == null) return;
        if (res.size() < level + 1) {
            res.add(new ArrayList<>());
        }
        res.get(level).add(node.val);
        levelHelper(res, node.left, level + 1);
        levelHelper(res, node.right, level + 1);
    }
}

没有用 Swift 来写的小伙伴么？
BFS，广度优先，算法复杂度 O(n) （Swift）
```swift
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 * public var val: Int
 * public var left: TreeNode?
 * public var right: TreeNode?
 * public init(_ val: Int) {
 * self.val = val
 * self.left = nil
 * self.right = nil
 * }
 * }
 */
class Solution {
    func levelOrder(_ root: TreeNode?) -> [[Int]] {
        guard let root = root else { return [] }
        
        var result: [[Int]] = []
        var queue: [TreeNode] = []
        queue.append(root)
        
        while !queue.isEmpty {
            let levelSize = queue.count
            var currentLevel: [Int] = []
            
            for _ in 0 ..< levelSize {
                let node = queue.removeFirst()
                currentLevel.append(node.val)
                if let left = node.left {
                    queue.append(left)
                }
                if let right = node.right {
                    queue.append(right)
                }
            }
            
            result.append(currentLevel)
        }
        
        return result
        
    }
}
```

GO语言版本实现：

func levelOrder(root *TreeNode) [][]int {
    var result [][]int
    if root == nil {
        return result
    }

    visited := make(map[int]int)

    queue := list.New()
    queue.PushBack(root)

    for queue.Len() > 0 {
        var curLevel []int
        count := queue.Len()
        for count > 0 {
            element := queue.Front()
            node := element.Value.(*TreeNode)

            if _, exist := visited[node.Val]; exist {
                continue
            }
            visited[node.Val]++

            curLevel = append(curLevel, node.Val)
            if node.Left != nil {
                queue.PushBack(node.Left)
            }
            if node.Right != nil {
                queue.PushBack(node.Right)
            }
            queue.Remove(element)
            count--
        }
        result = append(result, curLevel)
    }
    return result
}

用c++实现的BFS解
class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
         // 题目需要返回一个二维数组 二维数组中的每一个元素都是一个一维数组 其中包括了每一层的值
         // 所以提前申明一个二维数组res 用来保存结果
        vector<vector<int>> res;
        // 判断是否为一个空树 如果空树直接返回空二维数组即可
        if(!root) return res;
        // 申明一个队列用来存储二叉树结点值
        queue<TreeNode*> q;
        // 将根节点推入queue中
        q.push(root);
        // 同时添加一个NULL指针用来标记每一层已经走到头
        q.push(NULL);
        // 申明一个数组cur 用来存储每一层的结果 每一层存储完成之后 重置cur
        vector<int> cur;
        // cout<<q.size()<<endl;
        while(!q.empty()){
            // 拿到此时queue中的头结点
            TreeNode *t = q.front();
            // 拿到之后直接队头元素弹出
            q.pop();
            if(t == NULL){
                // 如果为空指针的话 说明这一层已经走完
                // 直接将cur数组添加到二维数组res中即可
                res.push_back(cur);
                // 将cur重置
                cur.resize(0);
                // 如果q的size大于0 说明还没有走到最后一层 接着添加一个NULL指针
                // 用来标记下一层的结束位置
                if(q.size()>0){
                    q.push(NULL);
                }
            }
            else{
                // 如果不为空 那么说明还有值 直接将val插入cur数组即可
                cur.push_back(t->val);
                // 同时如果节点有左子树 右子树 那么将左子树和右子树push进队中 用作下一层的遍历
                if(t->left){
                    q.push(t->left);
                }
                if(t->right){
                    q.push(t->right);
                }
            }
        }
        return res;
    }
};

用java实现的深度优先搜索
public List<List<Integer>> levelOrder(TreeNode root) {
            // 递归的层级
            int level = 0;
            return dfs(root, level, new ArrayList<>());
        }

        private List<List<Integer>> dfs(TreeNode root, int level, List<List<Integer>> result) {
            // 递归终止条件，当前节点为空
            if (root == null) {
                return new ArrayList<>();
            }
            // 如果当前层级没有结果，则新增一个list
            List<Integer> curList;
            if (result.size() == level) {
                curList = new ArrayList<>();
                curList.add(root.val);
                result.add(curList);
            } else {
                curList = result.get(level);
                curList.add(root.val);
                result.set(level, curList);
            }

            dfs(root.left, level + 1, result);
            dfs(root.right, level + 1, result);

            return result;
        }