Question

鉴于一个完美的二叉树，我需要反转交替的水平：

Given tree: 
           a
        /     \
       b       c
     /  \     /  \
    d    e    f    g
   / \  / \  / \  / \
   h  i j  k l  m  n  o 

Modified tree:
           a
        /     \
       c       b
     /  \     /  \
    d    e    f    g
   / \  / \  / \  / \
  o  n m  l k  j  i  h

我正在尝试使用递归来执行inorder遍历并在另一个inorder遍历中修改树。

public static void reverseAltLevels(TreeNode node) {
    if (node == null)
        return;
    ArrayList<TreeNode> list = new ArrayList<TreeNode>();
    storeAltNodes(node, list, 0);

    Collections.reverse(list);
    System.out.println();
    for (TreeNode n : list)
        System.out.print(n.data + " ");
    modifyTree(node, list, 0, 0);
}

public static void storeAltNodes(TreeNode node, ArrayList<TreeNode> list,
        int level) {
    if (node == null)
        return;
    storeAltNodes(node.left, list, level + 1);
    if (level % 2 != 0) {
        list.add(node);
    }
    storeAltNodes(node.right, list, level + 1);
}

public static int modifyTree(TreeNode node, ArrayList<TreeNode> list,
        int index, int level) {
    if (node == null)
        return index;
    index = modifyTree(node.left, list, index, level + 1);
    if (level % 2 != 0) {
        node.data = list.get(index).data;
        index++;
    }
    index = modifyTree(node.right, list, index, level + 1);
    return index;
}

public static void inOrder(TreeNode node) {
    if (node == null)
        return;
    inOrder(node.left);
    System.out.print(node.data + " ");
    inOrder(node.right);
}

我将把root传递给reverseAltLevels（）函数，然后我将调用另一个函数。

但是我无法弄清楚我的代码的确切问题，在Eclipse中尝试调试，对我来说似乎没关系。原始的Inorder遍历：

h d i b j e k a l f m c n g o

修改后的预期结果：

o d n c m e l a k f j b i g h

我的输出：

o d n c m e l a l f m c n g o

Answer 1

您的代码存在问题

list.add(node);

现在列表与原始对象

具有相同的引用

方法

public static int modifyTree(TreeNode node, ArrayList<TreeNode> list,
            int index, int level)

您正在设置节点数据。

node.data = list.get(index).data;

导致修改数组列表中的数据。

解决您的问题。使用字符串的Arraylist来存储数据，而不是存储对象本身

反转二叉树的备用级别

1 个答案: