получить максимальное значение бинарного дерева поиска в js

1

Я слежу за этим файлом структуры данных JS от udemy на двоичных деревьях поиска. У нас есть метод, чтобы найти максимальное значение через рекурсию.

Я думал больше о сравнении всех чисел, таких как

BST.prototype.getMaxVal = function() {
  let num = null;
  if (num === null) num = this.value;
  else if (this.value > num) num = this.value;
  if (this.left) return this.left.getMaxVal();
  return num;
}

но ответ

BST.prototype.getMaxVal = function() {
  if (this.right) return this.right.getMaxVal();
  else return this.value;
}

105 - последнее число без собственного листа, но этот метод находит 107 перед ним? как он находит, что без какой-либо логики сравнения?

function BST(value) {
  this.value = value;
  this.left = null;
  this.right = null;
}

BST.prototype.insert = function(value) {
  if (value <= this.value) {
    if (!this.left) this.left = new BST(value);
    else this.left.insert(value);
  } else {
    if (!this.right) this.right = new BST(value);
    else this.right.insert(value);
  }

  return this;
}


const bst = new BST(50); 

bst.insert(30);
bst.insert(70);
bst.insert(107);
bst.insert(60);
bst.insert(59);
bst.insert(20);
bst.insert(45);
bst.insert(35);
bst.insert(85);
bst.insert(105);
bst.insert(10);

bst.getMaxVal();

https://repl.it/repls/NumbYellowgreenPlans

  • 0
    Ну, сравнения сделаны в методе insert . Тогда вы знаете, что obj.left всегда будет ниже, а obj.right всегда будет выше.
  • 0
    правильно. Мой вопрос: как функция getMaxVal, не имеющая сравнения, находит наименьшее число в obj.right?
Показать ещё 2 комментария
Теги:
data-structures

3 ответа

4

Таким образом, это визуальное представление BST. Если какое-то значение меньше вас, вы передаете его слева, и пусть левый суб-BST определяет, куда его поместить. Если какое-то значение больше, чем вы, передайте его на правый суб-BST и дайте ему возможность решить, где поставить значение.

Изображение 174551

В этой настройке гарантируется, что в левой части листа наибольшее значение должно быть наименьшим значением, а справа - большим листом, оно содержит наибольшее значение. Поэтому идея о том, с каждой точки зрения BST, либо его левое дерево ничего не имеет, либо его значение должно быть меньше меня. Таким образом, алгоритмы записывают:

BST.prototype.getMinVal = function() {
  // if left tree is not null, it must be smaller tha me. Return its value
  if (this.left) return this.left.getMinVal();
  // if left tree is null, indicate i'm the smallest available, return me instead.
  else return this.value;
}

Обновление 1

Следует отметить одно. BST предназначен для того, чтобы служить такой цели. Его данные при вставке структурированы, чтобы избежать необходимости обхода всего дерева. Его значение хорошо упорядочено, поэтому вам не нужно проходить каждый узел при поиске значения min/max. Если вам нужны ваши алгоритмы, вы не используете его правильно, даже функция создает правильный логический вывод.

Поделиться
1

По определению сквозной обход BST возвращает возвращаемые отсортированные значения. insert() выполнила сравнение и применила эту логику.

Обход в порядке эквивалентен сканированию узлов слева направо (вы можете попробовать это вручную). Мы не фокусируемся на листовых узлах. Все, что находится в левом поддереве 107 узла (где находится 105), меньше 107.

Здесь ваш BST:

{
    "value": 50,
    "left": {
        "value": 30,
        "left": {
            "value": 20,
            "left": { "value": 10, "left": null, "right": null },
            "right": null
        },
        "right": {
            "value": 45,
            "left": { "value": 35, "left": null, "right": null },
            "right": null
        }
    },
    "right": {
        "value": 70,
        "left": {
            "value": 60,
            "left": { "value": 59, "left": null, "right": null },
            "right": null
        },
        "right": {
            "value": 107,
            "left": {
                "value": 85,
                "left": null,
                "right": { "value": 105, "left": null, "right": null }
            },
            "right": null
        }
    }
}

См. Здесь больше для BST:
VisuAlgo - Дерево двоичного поиска, Дерево AVL

Поделиться
0

Итак, если я правильно понимаю ваш вопрос, ответ заключается в том, что из-за того, как структурировано двоичное дерево, методы getMaxVal и getMinVal просто должны располагаться как можно правее или слева (соответственно), насколько это возможно, чтобы найти правильное значение. Если вы посмотрите на метод вставки, сравнение уже "запекло" в структуре "дерева", которое создается серией вызовов этого метода. Когда мы вызываем insert на 105, он в конечном итоге будет помещен в "правильное" свойство 85, что само является "левым" свойством 107. Функция getMaxVal просто использует тот факт, что метод insert гарантирует, что значение value ниже наибольшего значения может быть вставлено справа от этого значения. Фактически, наибольшее значение в любой момент времени никогда не будет иметь к нему никакого права, поэтому мы можем просто пересечь дерево справа, пока не достигнем значения, которое не имеет "правильного" свойства, и мы знаем что это максимальное значение в дереве.

Надеюсь, это поможет!

Поделиться
  • 0
    Я не видел предыдущий комментарий, пока не опубликовал свой ответ - функция getMinValue работает точно так же. Он использует тот факт, что метод вставки никогда не может размещать что-либо слева от самого низкого значения, если только элемент, который он вставляет, еще ниже.

Ещё вопросы

Сообщество Overcoder
Наверх
Меню