特定深度节点链表

        1
       /  \ 
      2    3
     / \    \ 
    4   5    7
   /
  8Copy

type TreeNode struct {
    Val   int
    Left  *TreeNode
    Right *TreeNode
}

type ListNode struct {
    Val  int
    Next *ListNode
}Copy

func createTree(arr []int, n int) *TreeNode {
    if n > len(arr)-1 {
        return nil
    }

    root := &TreeNode{Val: arr[n]}
    root.Left = createTree(arr, n*2+1)
    root.Right = createTree(arr, n*2+2)

    return root
}Copy

func treeDepth(root *TreeNode) int {
    if root == nil {
        return 0
    }
    left := treeDepth(root.Left)
    right := treeDepth(root.Right)

    if left > right {
        return left + 1
    } else {
        return right + 1
    }
}Copy

func listOfDepth(tree *TreeNode) []*ListNode {
    // 计算最大深度
    maxDepth := treeDepth(tree)
    l := []*TreeNode{}
    node := []*ListNode{}
    // 记录循环层次
    sum := 0
    for {
        t := []*TreeNode{}
        for i := 0; i < len(l); i++ {
            if l[i].Left != nil {
                t = append(t, l[i].Left)
            }
            if l[i].Right != nil {
                t = append(t, l[i].Right)
            }
        }
        if len(l) < 1 {
            t = []*TreeNode{tree}
        }
        l = t
        sum++

        // 生成链表头
        head := &ListNode{Val: t[0].Val}
        prev := head
        for i := 1; i < len(t); i++ {
            prev.Next = &ListNode{Val: t[i].Val}
            prev = prev.Next
        }

        // 加入链表
        node = append(node, head)
        // 外层跳出,指定层次，以及大于树的最大深度
        if sum >= maxDepth {
            break
        }
    }
    return node
}Copy