Как найти максимальную глубину дерева

01 Предметы и препараты

Сегодня я представил 23-й выпуск легкого уровня в алгоритме LetCode (номер 104 названия). Дайте бинарное дерево, чтобы найти его максимальную глубину. Максимальная глубина — количество узлов на максимальном пути от корневого узла до максимального узера листьев. Листья являются узлами без дочерних узлов.

Например: учитывая бинарное дерево [3, 9, 20, NULL, NULL, 15, 7],

    3
   / 
  9  20
     / 
    15  7

Возвращает его глубину = 3.

02 Первое решение

Максимальная глубина — это количество узлов, содержащихся на корневом узле к траектору самого дальнеготельного листового узла. Возьмите два вилочных дерева выше, самый длинный путь имеет два: 3-> 20-> 15, 3-> 20-> 7, эти Два номера узлов на пути линии 3, поэтому, наконец, его глубина 3 выводы.

Особые обстоятельства: Когда входящее двоичное дерево пустое, у него нет узлов, его глубина 0.

Особые обстоятельства: Когда только корневой узел, его глубина 1, только его собственный узел.

Нормальная ситуация: мы можем попробовать шаг за шагом, простой процессом расчета глубины двоичного дерева, или вышеуказанное двоичное дерево в качестве примера.

Начиная с корневого узла, количество узлов составляет 1, потому что он имеет только один узел.

Введите узел дочернего узела корневого узла, в это время самый длинный путь должен рассчитать максимальный путь этого левого субпода и 20 этого правого ребенка. Очевидно, что 9 является узлом листьев, только один узел сама; и 20 имеет свой собственный Узел ребенка, на данный момент, вам нужно будет рассчитать самый длинный путь от 20.

20 Существует левый суб-узел 15, правый узел 7, а затем продолжают вычислять самый длительный путь 15 и 7, а 15 и 7 — это узлы листьев, поэтому количество узлов составляет всего 1, плюс 20 узлов Это относится к корневому узлу узел для детей, самый длинный путь в 20 узле 2.

Два подмазера 9, 20, максимальный путь узера 9 ребенка составляет 1, максимальное количество узлов равно 2, а максимальное значение принимается, а сам корневой узел добавляется. Количество узлов, 1 + 2 = 3, 3 — количество узлов на самом длинном пути, то есть глубина бинарного дерева.

Анализ здесь, мы знаем, чтобы рассчитать количество узлов из корневого узла в самый дальний узел листьев, вам необходимо рассчитать максимальный путь левого и правого дочерних узлов, и рассчитать максимальный путь левого и правого дочерних узлов, Он будет рассчитан. Они имеют самый длинный путь левого и правого дочерних узлов ниже, и мы можем использовать рекурсивный, после количества узлов нижнего листа, замечательный слой придумает максимум.

public int maxDepth(TreeNode root) {
    if (root == null) {
        return 0;
    }
    int left = maxDepth(root.left);
    int right = maxDepth(root.right);
    return 1 + Math.max(left, right);
}

03 Второе решение

Поскольку рекурсия можно использовать, мы также можем попробовать способ использовать обход. Начиная с корневого узла, верхняя часть дочернего узла автоматически сохраняется, а подсуд прохождения хранится при прохождении, и он проходит на все подмазки.

public int maxDepth2(TreeNode root) {
    if (root == null) {
        return 0;
    }
    int depth = 0;
    Queue<TreeNode> q = new LinkedList<>();
    q.offer(root);
    while (!q.isEmpty()) {
        Queue<TreeNode> tem = new LinkedList<>();
        while(!q.isEmpty()){
            TreeNode node = q.poll();
            if (node.left != null) {
                tem.offer(node.left);
            }
            if (node.right != null) {
                tem.offer(node.right);
            }
        }
        q = tem;
        depth++;
    }
    return depth;
}

04 Третье решение

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

public int maxDepth3(TreeNode root) {
    if (root == null) {
        return 0;
    }
    int depth = 0;
    Queue<TreeNode> q = new LinkedList<>();
    q.offer(root);
    while (!q.isEmpty()) {
        int n = q.size();
        while(n-- > 0){
            TreeNode node = q.poll();
            if (node.left != null) {
                q.offer(node.left);
            }
            if (node.right != null) {
                q.offer(node.right);
            }
        }
        depth++;
    }
    return depth;
}

05 Проверка и тест

Для приведенных выше двух решений простая бинарное дерево провело тест на данные.

public static void main(String[] args) {
    Easy_104_MaximumDepthOfBinaryTree instance = new Easy_104_MaximumDepthOfBinaryTree();
    TreeNode t = new TreeNode(1);
    TreeNode t2 = new TreeNode(2);
    TreeNode t3 = new TreeNode(3);
    TreeNode t4 = new TreeNode(4);
    TreeNode t5 = new TreeNode(5);
    TreeNode t6 = new TreeNode(6);
    TreeNode t7 = new TreeNode(7);
    TreeNode t8 = new TreeNode(8);
    t.left = t2;
    t.right = t3;
    t2.left = t4;
    t2.right = t5;
    t3.left = t6;
    t3.right = t7;
    t7.left = t8;
    long start = System.nanoTime();
    int result = instance.maxDepth(t);
    long end = System.nanoTime();
    System.out.Println («MaxDepth --- Выход:» + Результат + ", при использовании:" + (конец-стартуе) / 1000 + "микросекунды");
    long start2 = System.nanoTime();
    int result2 = instance.maxDepth2(t);
    long end2 = System.nanoTime();
         System.out.Println («MaxDepth2 --- Выход:» + Realse2 + ", при использовании:" + (end2-start2) / 1000 + "микросекунды");
    long start3 = System.nanoTime();
    int result3 = instance.maxDepth3(t);
    long end3 = System.nanoTime();
         System.out.Println («MaxDepth3 --- Выход:» + Realse3 + ", при использовании:" + (end3-start3) / 1000 + "микросекунды");
}

Результаты теста следующие:

MaxDepth --- Выход: 4, время: 23 микросекунда
 Maxdepth2 --- Выход: 4, используемый: 586 микросекунд
 Maxdepth3 --- Выход: 4, используемый: 16 микросекунд

06 Маленький узел

Вышеупомянутое содержимое, если у вас есть какие-либо хорошие идеи решения, предложения или другие вопросы, вы можете отправить сообщение ниже, похвалы, оставьте сообщение, вперед — это самое большое возвращение и поддержка для меня!

Ivandur, большое спасибо.
shmkv, там просто дичь пишут, вот здесь дали нормальный понятный ответ.
А вот еще вопрос, у меня есть функция branches():

1
2
3
4
5
6
7
8
9
10
11

int branches(TNode *&tr, int n) {
    int count = 0;
    if (tr == NULL)
        return 0;
 
    if (tr->data == n)
        return count;
 
    return ++count + branches(((tr->data > n) ? tr->left : tr->right), n);
 
}

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