Рекурсивное двоичное дерево поиска x = изменение (x)

Вот изображение того, что должен делать мой код.

Before Call:
            +----+
            | -9 |
            +----+
           /      \
          /        \
      +----+      +----+
      |  3 |      | 15 |
      +----+      +----+
     /           /      \
    /           /        \
+----+      +----+      +----+
|  0 |      | 12 |      | 24 |
+----+      +----+      +----+
           /      \
          /        \
      +----+      +----+
      |  6 |      | -3 |
      +----+      +----+

After Call:
            +----+
            | -9 |
            +----+
           /      \
          /        \
      +----+      +----+
      |  6 |      | 30 |
      +----+      +----+
     /           /      \
    /           /        \
+----+      +----+      +----+
|  0 |      | 24 |      | 48 |
+----+      +----+      +----+
           /      \
          /        \
      +----+      +----+
      | 12 |      | -3 |
      +----+      +----+

В основном эта проблема требует, чтобы я удвоил все значения данных, превышающие 0, в бинарном дереве целых чисел. Мой код ниже делает это для нескольких значений, но останавливается раньше. Я не уверен, как исправить это рекурсивно. Вот как выглядит мой вывод для дерева, указанного выше.

       overallRoot
         _[-9]_______________
        /                    \
    _[6]                 _____[30]
   /                    /         \
[0]                _[12]           [24]
                  /     \
               [6]       [-3]
public void doublePositives() {
    doublePositives(overallRoot);
}

private IntTreeNode doublePositives(IntTreeNode root) {
    if(root != null) {
        if(root.data > 0) {
            root.data = 2* root.data;
        }else {
            root.left = doublePositives(root.left);
            root.right= doublePositives(root.right);
        }
    }
    return root;
}

Ответ 1

Вам все равно нужно пересечь дерево, если вы удваиваете node. Опустите else, чтобы вы всегда проходили. Кроме того, я удалил присваивания, потому что вы не меняете древовидную структуру:

if(root != null) {
    if(root.data > 0) {
        root.data = 2 * root.data;
    }
    doublePositives(root.left);
    doublePositives(root.right);
}

Ответ 2

Похож на логическую проблему - вы будете только удваивать значения дочерних узлов отрицательных узлов:

    if(root.data > 0) {
        root.data = 2* root.data;
    }else {
        root.left = doublePositives(root.left);
        root.right= doublePositives(root.right);
    }

Если значение корня положительное, вы никогда не получите root.left и root.right. Что-то вроде этого было бы лучше:

    if(root.data > 0) {
        root.data = 2* root.data;
    }
    root.left = doublePositives(root.left);
    root.right= doublePositives(root.right);

Ответ 3

Попробуйте следующее: Вы ошибались в условном заявлении. Это должно было быть написано так. Если root имеет данные положительные - сделайте это двойным, roger это! и вне! На следующем шаге выполните для левого и правого дочерних узлов.

Кроме того, обратите внимание на это, вам не нужно возвращать что-либо (отличное от void) в рекурсивной функции doublePositives().

public void iWillDoit() {
        doublePositives(Root);
    }

    private void doublePositives(IntTreeNode root) {
        if(root != null) {
            if(root.data > 0) 
            {
                root.data = 2* root.data;
            }  
            doublePositives(root.left);
            doublePositives(root.right);      
      }
   }

Ответ 4

Вы не выполняете рекурсивные вызовы, когда корень положителен.

Вы делаете рекурсивные вызовы только тогда, когда корень отрицательный. Чтобы исправить это, просто удалите else.

private IntTreeNode doublePositives(IntTreeNode root) {
    if(root != null) {
        if(root.data > 0) {
            root.data = 2* root.data;
        }
        root.left = doublePositives(root.left);
        root.right= doublePositives(root.right);
    }
    return root;
}