Go中的追加行为不一致?

时间:2019-02-11 01:35:06

标签: go binary-tree tree-traversal

我正在编写一个函数,该函数返回二叉树的节点值的垂直顺序遍历。 (即,从上到下,逐列)。这是预期输入和输出的示例:

Input: [3,9,8,4,0,1,7,null,null,null,2,5] (0's right child is 2 and 1's left child is 5)

     3
    /\
   /  \
   9   8
  /\  /\
 /  \/  \
 4  01   7
    /\
   /  \
   5   2

Output:

[
  [4],
  [9,5],
  [3,0,1],
  [8,2],
  [7]
]

我的函数将输出除[8,2]之外的所有内容,而我得到的是[2,8]

[[4] [9 5] [3 0 1] [2 8] [7]]

这就是我的功能:

func verticalOrder(root *TreeNode) [][]int {
    if root == nil {
        return [][]int{}
    }
    var (
        hd       int
        m        map[int][]int
        vals     [][]int
        min      int
        max      int
        traverse func(t *TreeNode, hd int, m map[int][]int)
    )
    m = make(map[int][]int)
    min = 0
    max = 0
    traverse = func(t *TreeNode, hd int, m map[int][]int) {
        if t == nil {
            return
        }
        m[hd] = append(m[hd], t.Val)
        if max < hd {
            max = hd
        }
        if min > hd {
            min = hd
        }
        traverse(t.Left, hd-1, m)
        traverse(t.Right, hd+1, m)
    }
    traverse(root, hd, m)
    for i := min; i <= max; i++ {
        vals = append(vals, m[i])
    }
    return vals
}

本质上,我正在使用哈希图来跟踪具有相同水平距离的节点,并将其附加到数组中。我要弄清楚的是我的输出如何与95一起正常工作,而不与82一起工作?任何反馈都非常感谢!

复制步骤

运行以下代码。您将得到[[4] [9 5] [3 0 1] [2 8] [7]]的输出;输出应为[[4] [9 5] [3 0 1] [8 2] [7]]。使我烦恼的是[9 5]是以正确的垂直顺序附加的,而[2 8]尽管相似,却没有,所以我不太确定从这里出发。

package main

import "fmt"

// TreeNode is a binary tree node.
type TreeNode struct {
    Val   int
    Left  *TreeNode
    Right *TreeNode
}

func verticalOrder(root *TreeNode) [][]int {
    if root == nil {
        return [][]int{}
    }

    var (
        hd       int
        m        map[int][]int
        vals     [][]int
        min      int
        max      int
        traverse func(t *TreeNode, hd int, m map[int][]int)
    )

    m = make(map[int][]int)
    min = 0
    max = 0
    traverse = func(t *TreeNode, hd int, m map[int][]int) {
        if t == nil {
            return
        }

        m[hd] = append(m[hd], t.Val)

        if max < hd {
            max = hd
        }
        if min > hd {
            min = hd
        }
        traverse(t.Left, hd-1, m)
        traverse(t.Right, hd+1, m)
    }

    traverse(root, hd, m)

    for i := min; i <= max; i++ {
        vals = append(vals, m[i])
    }

    return vals
}

func main() {
    root := &TreeNode{
        Val: 3,
        Left: &TreeNode{
            Val: 9,
            Left: &TreeNode{
                Val:   4,
                Left:  nil,
                Right: nil,
            },
            Right: &TreeNode{
                Val:  0,
                Left: nil,
                Right: &TreeNode{
                    Val:   2,
                    Left:  nil,
                    Right: nil,
                },
            },
        },
        Right: &TreeNode{
            Val: 8,
            Left: &TreeNode{
                Val: 1,
                Left: &TreeNode{
                    Val:   5,
                    Left:  nil,
                    Right: nil,
                },
                Right: nil,
            },
            Right: &TreeNode{
                Val:   7,
                Left:  nil,
                Right: nil,
            },
        },
    }

    fmt.Println(verticalOrder(root))
}

1 个答案:

答案 0 :(得分:2)

我与append无关。

您正在执行二叉树的DFS遍历,该顺序称为该树的DFS顺序。问题是树的DFS顺序不是从上到下。

您的代码在节点2之前访问节点8,因此代码m[hd] = append(m[hd], t.Val)使[2 8]而不是[8 2]。没有什么矛盾之处。

要解决此问题,可以使用BFS遍历树,也可以将深度信息保留在m中并相应地对每个m[hd]进行排序。

通常来说,BFS是一个更好的主意,但是可以很快被黑客入侵。