Java 在给定深度对节点的所有子节点执行交换

我试图编写一个函数，在给定深度的节点的所有子节点上执行交换

假设我们有一棵这样的树：

   1 
  / \ 
 2   3 

  1 
 / \ 
3   2 

public void swap(TreeNode node, int[] swaps, int i, int arraySize, int depth) {
        if(arraySize == 0) return;

        if(depth < swaps[i]) {
            swap(node.left, swaps, i+1, arraySize-1, depth+1);
        }

        if(depth == swaps[i]) {
            TreeNode temp = node.left;
            node.left = node.right;
            node.right = temp;
        }

        if(depth != swaps[i]) {
            swap(node.right, swaps, i+1, arraySize-1, depth+1);
        }

        if(depth == swaps[i]) {
            TreeNode temp2 = node.left;
            node.left = node.right;
            node.right = temp2;
        }
    }

以及一个

数组

，其中包含我要在其上执行交换的节点的深度

如果数组包含

1

，那么我们交换该深度的所有节点的子节点。然后，该树将如下所示：

   1 
  / \ 
 2   3 

  1 
 / \ 
3   2 

public void swap(TreeNode node, int[] swaps, int i, int arraySize, int depth) {
        if(arraySize == 0) return;

        if(depth < swaps[i]) {
            swap(node.left, swaps, i+1, arraySize-1, depth+1);
        }

        if(depth == swaps[i]) {
            TreeNode temp = node.left;
            node.left = node.right;
            node.right = temp;
        }

        if(depth != swaps[i]) {
            swap(node.right, swaps, i+1, arraySize-1, depth+1);
        }

        if(depth == swaps[i]) {
            TreeNode temp2 = node.left;
            node.left = node.right;
            node.right = temp2;
        }
    }

我的函数如下所示：

   1 
  / \ 
 2   3 

  1 
 / \ 
3   2 

public void swap(TreeNode node, int[] swaps, int i, int arraySize, int depth) {
        if(arraySize == 0) return;

        if(depth < swaps[i]) {
            swap(node.left, swaps, i+1, arraySize-1, depth+1);
        }

        if(depth == swaps[i]) {
            TreeNode temp = node.left;
            node.left = node.right;
            node.right = temp;
        }

        if(depth != swaps[i]) {
            swap(node.right, swaps, i+1, arraySize-1, depth+1);
        }

        if(depth == swaps[i]) {
            TreeNode temp2 = node.left;
            node.left = node.right;
            node.right = temp2;
        }
    }

公共无效交换（树节点，int[]交换，int i，int arraySize，int depth）{
如果（arraySize==0）返回；
if（深度<交换[i]）{
交换（node.left，交换，i+1，arraySize-1，depth+1）；
}
如果（深度==交换[i]）{
树节点温度=node.left；
node.left=node.right；
node.right=temp；
}
if（深度！=交换[i]）{
交换（node.right，交换，i+1，arraySize-1，depth+1）；
}
如果（深度==交换[i]）{
TreeNode temp2=node.left；
node.left=node.right；
node.right=temp2；
}
}

---

当我在示例树上运行此方法，并执行树的顺序遍历时，它会给我

2 1 2

交换行

node.right=temp2

和行

node.left=node.right

例如：

public void swap(TreeNode node, int[] swaps, int i, int arraySize, int depth) {
    if(arraySize == 0) return;
    // Swap left
    if(depth < swaps[i]) {
        swap(node.left, swaps, i+1, arraySize-1, depth+1);
    }
    // Swap right
    if(depth != swaps[i]) {
        swap(node.right, swaps, i+1, arraySize-1, depth+1);
    }

    // Swap us
    if(depth == swaps[i]) {
        TreeNode temp2 = node.left;
        node.left = node.right;
        node.right = temp2;
    }
}

公共无效交换（树节点，int[]交换，int i，int arraySize，int depth）{
如果（arraySize==0）返回；
//向左调换
if（深度<交换[i]）{
交换（node.left，交换，i+1，arraySize-1，depth+1）；
}
//互换权
if（深度！=交换[i]）{
交换（node.right，交换，i+1，arraySize-1，depth+1）；
}
//交换我们
如果（深度==交换[i]）{
TreeNode temp2=node.left；
node.left=node.right；
node.right=temp2；
}
}

现在更新。你有一部分是对的。现在我得到了

213

。但是在我使用swap函数之后，我应该得到

3 1 2

，你重复了两次swap代码。移除其中一个，它应该是正确的。嗯，这起作用了。但对于一棵更大的树，这将导致一个问题。现在的情况是，我先用

node.left

递归调用，然后用

node.right

递归调用。我建议先调用left，然后调用right，然后在当前级别上执行交换。如果我对你的问题理解正确，你介意用代码更新你的问题吗？这样我就不会误会了？