特定深度節點連結串列

pardon110發表於2020-07-24

題面

給定一棵二叉樹，設計一個演算法，建立含有某一深度上所有節點的連結串列（比如，若一棵樹的深度為 D，則會建立出 D 個連結串列）。返回一個包含所有深度的連結串列的陣列。

示例：
輸入：[1,2,3,4,5,null,7,8]

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

輸出：[[1],[2,3],[4,5,7],[8]]

來源：力扣（LeetCode）
連結：leetcode-cn.com/problems/list-of-d...

資料結構

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

type ListNode struct {
    Val  int
    Next *ListNode
}

分析

  1. 深度遞迴計算樹的層次
  2. 迴圈佇列每次記錄上一層節點
  3. 根據每層節點構建連結串列
  4. 外層迴圈記數，與樹的最大層比較，作為終止條件

陣列建樹

有序陣列構建二叉樹，用遞迴
分析 一維變二維，找出 父子索引關係 n,n*2+1,n*2+2

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
}

深度計算

求二叉樹深度，左右二選一，大者出眾

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
    }
}

題解


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
}
本作品採用《CC 協議》，轉載必須註明作者和本文連結

相關文章