PHP | LeetCode

🌊  Водоворот знаний в Кодовороте 🤿 Погружайся в мир лучших видео уроков по программированию. Каждый день на канале выходит полезный контент. Кодируй своё будущее вместе с нами! ⛓ Подпишись

#Medium Задача: 114. Flatten Binary Tree to Linked List "Связный список" должен использовать тот же класс TreeNode, где указатель на правого ребенка указывает на следующий узел в списке, а указатель на левого ребенка всегда равен null. "Связный список" должен быть в том же порядке, что и обход бинарного дерева в прямом порядке. Пример:

Input: root = [1,2,5,3,4,null,6]
Output: [1,null,2,null,3,null,4,null,5,null,6]

👨‍💻 Алгоритм: 1️⃣Плоское преобразование дерева: Рекурсивно преобразуем левое и правое поддеревья заданного узла, сохраняя соответствующие конечные узлы в leftTail и rightTail. 2️⃣Установка соединений: Если у текущего узла есть левый ребенок, выполняем следующие соединения: leftTail.right = node.right node.right = node.left node.left = None 3️⃣Возврат конечного узла: Возвращаем rightTail, если у узла есть правый ребенок, иначе возвращаем leftTail. 😎 Решение:

class TreeNode {
    public $val = 0;
    public $left = null;
    public $right = null;

    public function __construct($value = 0, $left = null, $right = null) {
        $this->val = $value;
        $this->left = $left;
        $this->right = $right;
    }
}

function flattenTree($node) {
    if ($node === null) {
        return null;
    }
    if ($node->left === null && $node->right === null) {
        return $node;
    }
    $leftTail = flattenTree($node->left);
    $rightTail = flattenTree($node->right);
    if ($leftTail !== null) {
        $leftTail->right = $node->right;
        $node->right = $node->left;
        $node->left = null;
    }
    return $rightTail === null ? $leftTail : $rightTail;
}

function flatten($root) {
    flattenTree($root);
}

🔥 ТОП ВОПРОСОВ С СОБЕСОВ 🔒 База собесов | 🔒 База тестовых

#Medium Задача: 113. Path Sum II Дан корень бинарного дерева и целое число targetSum. Верните все пути от корня до листа, где сумма значений узлов в пути равна targetSum. Каждый путь должен быть возвращён как список значений узлов, а не ссылок на узлы. Путь от корня до листа — это путь, начинающийся от корня и заканчивающийся на любом листовом узле. Лист — это узел без детей. Пример:

Input: root = [5,4,8,11,null,13,4,7,2,null,null,5,1], targetSum = 22
Output: [[5,4,11,2],[5,8,4,5]]
Explanation: There are two paths whose sum equals targetSum:
5 + 4 + 11 + 2 = 22
5 + 8 + 4 + 5 = 22

👨‍💻 Алгоритм: 1️⃣Определение функции recurseTree: Функция принимает текущий узел (node), оставшуюся сумму (remainingSum), которая необходима для продолжения поиска вниз по дереву, и список узлов (pathNodes), который содержит все узлы, встреченные до текущего момента на данной ветке. 2️⃣Проверка условий: На каждом шаге проверяется, равна ли оставшаяся сумма значению текущего узла. Если это так и текущий узел является листом, текущий путь (pathNodes) добавляется в итоговый список путей, который должен быть возвращен. 3️⃣Обработка всех ветвей: Учитывая, что значения узлов могут быть отрицательными, необходимо исследовать все ветви дерева до самых листьев, независимо от текущей суммы по пути. 😎 Решение:

function pathSum($root, $sum) {
    $pathsList = [];
    $pathNodes = [];
    $recurseTree = function($node, $remainingSum, &$pathNodes, &$pathsList) use (&$recurseTree) {
        if (!$node) {
            return;
        }
        array_push($pathNodes, $node->val);
        if ($remainingSum === $node->val && $node->left === null && $node->right === null) {
            array_push($pathsList, $pathNodes);
        } else {
            $recurseTree($node->left, $remainingSum - $node->val, $pathNodes, $pathsList);
            $recurseTree($node->right, $remainingSum - $node->val, $pathNodes, $pathsList);
        }
        array_pop($pathNodes);
    };
    $recurseTree($root, $sum, $pathNodes, $pathsList);
    return $pathsList;
}

🔥 ТОП ВОПРОСОВ С СОБЕСОВ 🔒 База собесов | 🔒 База тестовых

👨‍💻 Чтобы стать более востребованным перцем в IT индустрии неплохо бы знать английский. Канал Hello Word в игровом стиле поможет улучшить твой English skill. 🤓У нас ты найдешь: 🟡 Тесты с пропуском слов 🟡 Мемы на английском 🟡 Полезные шпаргалки для изучения 😎 Расширяй свои навыки и покоряй начинай покорять западную индустрию. Испытай свои знания и попробуй пройти тест.

#easy Задача: 112. Path Sum Дан корень бинарного дерева и целое число targetSum. Верните true, если в дереве существует путь от корня до листа, такой, что сумма всех значений вдоль пути равна targetSum. Лист — это узел без детей. Пример:

Input: root = [5,4,8,11,null,13,4,7,2,null,null,null,1], targetSum = 22
Output: true
Explanation: The root-to-leaf path with the target sum is shown.

👨‍💻 Алгоритм: 1️⃣Инициализация стека: Начать с помещения в стек корневого узла и соответствующей оставшейся суммы, равной sum - root.val. 2️⃣Обработка узлов: Извлечь текущий узел из стека и вернуть True, если оставшаяся сумма равна 0 и узел является листом. 3️⃣Добавление дочерних узлов в стек: Если оставшаяся сумма не равна нулю или узел не является листом, добавить в стек дочерние узлы с соответствующими оставшимися суммами. 😎 Решение:

$hasPathSum = function ($root, $sum) {
    if (!$root) return false;
    $nodeStack = [];
    $sumStack = [];
    array_push($nodeStack, $root);
    array_push($sumStack, $sum - $root->val);
    while (count($nodeStack) > 0) {
        $currentNode = array_pop($nodeStack);
        $currSum = array_pop($sumStack);
        if (!$currentNode->left && !$currentNode->right && $currSum === 0)
            return true;
        if ($currentNode->right) {
            array_push($nodeStack, $currentNode->right);
            array_push($sumStack, $currSum - $currentNode->right->val);
        }
        if ($currentNode->left) {
            array_push($nodeStack, $currentNode->left);
            array_push($sumStack, $currSum - $currentNode->left->val);
        }
    }
    return false;
};

🔥 ТОП ВОПРОСОВ С СОБЕСОВ 🔒 База собесов | 🔒 База тестовых

#easy Задача: 111. Minimum Depth of Binary Tree Дано бинарное дерево, найдите его минимальную глубину. Минимальная глубина - это количество узлов вдоль самого короткого пути от корневого узла до ближайшего листового узла. Пример:

Input: root = [3,9,20,null,null,15,7]
Output: 2

👨‍💻 Алгоритм: 1️⃣Мы будем использовать метод обхода в глубину (dfs) с корнем в качестве аргумента. Базовое условие рекурсии: это для узла NULL, в этом случае мы должны вернуть 0. 2️⃣Если левый ребенок корня является NULL: тогда мы должны вернуть 1 + минимальную глубину для правого ребенка корневого узла, что равно 1 + dfs(root.right). 3️⃣Если правый ребенок корня является NULL: тогда мы должны вернуть 1 + минимальную глубину для левого ребенка корневого узла, что равно 1 + dfs(root.left). Если оба ребенка не являются NULL, тогда вернуть 1 + min(dfs(root.left), dfs(root.right)). 😎 Решение:

$minDepth = function($root) {
    $dfs = function($root) use (&$dfs) {
        if ($root === null) {
            return 0;
        }
        if ($root->left === null) {
            return 1 + $dfs($root->right);
        } else if ($root->right === null) {
            return 1 + $dfs($root->left);
        }
        return 1 + min($dfs($root->left), $dfs($root->right));
    };
    return $dfs($root);
};

🔥 ТОП ВОПРОСОВ С СОБЕСОВ 🔒 База собесов | 🔒 База тестовых

💸 Работа для IT'шников Выбери своё направление ⤵ 1. Frontend 2. Python 3. Java 4. Тестировщик QA 5. Data Science 6. DevOps 7. C# 8. С/C++ 9. Golang 10. PHP 11. Kotlin 12. Swift

#easy Задача: 110. Balanced Binary Tree Дано бинарное дерево, определите, является ли оно сбалансированным по высоте. Пример:

Input: root = [3,9,20,null,null,15,7]
Output: true

👨‍💻 Алгоритм: 1️⃣Сначала мы определяем функцию height, которая для любого узла p в дереве T возвращает: -1, если p является пустым поддеревом, т.е. null; 1 + max(height(p.left), height(p.right)) в противном случае. 2️⃣Теперь, когда у нас есть метод для определения высоты дерева, остается только сравнить высоты детей каждого узла. Дерево T с корнем r является сбалансированным тогда и только тогда, когда высоты его двух детей отличаются не более чем на 1 и поддеревья каждого ребенка также сбалансированы. 3️⃣Следовательно, мы можем сравнить высоты двух дочерних поддеревьев, а затем рекурсивно проверить каждое из них: Если root == NULL, возвращаем true. Если abs(height(root.left) - height(root.right)) > 1, возвращаем false. В противном случае возвращаем isBalanced(root.left) && isBalanced(root.right). 😎 Решение:

function height($root) {
    if ($root === null) {
        return -1;
    }
    return 1 + max(height($root->left), height($root->right));
}

function isBalanced($root) {
    if ($root === null) {
        return true;
    }
    return (
        abs(height($root->left) - height($root->right)) < 2 &&
        isBalanced($root->left) &&
        isBalanced($root->right)
    );
}

🔥 ТОП ВОПРОСОВ С СОБЕСОВ 🔒 База собесов | 🔒 База тестовых

#medium Задача: 109. Convert Sorted List to Binary Search Tree Дана голова односвязного списка, элементы которого отсортированы в порядке возрастания. Преобразуйте его в сбалансированное по высоте бинарное дерево поиска. Пример:

Input: head = [-10,-3,0,5,9]
Output: [0,-3,9,-10,null,5]
Explanation: One possible answer is [0,-3,9,-10,null,5], which represents the shown height balanced BST.

👨‍💻 Алгоритм: 1️⃣Поскольку нам дан односвязный список, а не массив, у нас нет прямого доступа к элементам списка по индексам. Нам нужно определить средний элемент односвязного списка. Мы можем использовать подход с двумя указателями для нахождения среднего элемента списка. В основном, у нас есть два указателя: slow_ptr и fast_ptr. slow_ptr перемещается на один узел за раз, тогда как fast_ptr перемещается на два узла за раз. К тому времени, как fast_ptr достигнет конца списка, slow_ptr окажется в середине списка. Для списка с четным количеством элементов любой из двух средних элементов может стать корнем BST. 2️⃣Как только мы находим средний элемент списка, мы отсоединяем часть списка слева от среднего элемента. Мы делаем это, сохраняя prev_ptr, который указывает на узел перед slow_ptr, т.е. prev_ptr.next = slow_ptr. Для отсоединения левой части мы просто делаем prev_ptr.next = None. 3️⃣Для создания сбалансированного по высоте BST нам нужно передать только голову связанного списка в функцию, которая преобразует его в BST. Таким образом, мы рекурсивно работаем с левой половиной списка, передавая оригинальную голову списка, и с правой половиной, передавая slow_ptr.next в качестве головы. 😎 Решение:

class ListNode {
    public $val;
    public $next;

    public function __construct($val = 0, $next = null) {
        $this->val = $val;
        $this->next = $next;
    }
}

class TreeNode {
    public $val;
    public $left;
    public $right;

    public function __construct($val = 0, $left = null, $right = null) {
        $this->val = $val;
        $this->left = $left;
        $this->right = $right;
    }
}

function sortedListToBST($head) {
    if (!$head) return null;
    $mid = findMiddleElement($head);
    $node = new TreeNode($mid->val);
    if ($head === $mid) return $node;
    $node->left = sortedListToBST($head);
    $node->right = sortedListToBST($mid->next);
    return $node;
}

function findMiddleElement($head) {
    $prevPtr = null;
    $slowPtr = $head;
    $fastPtr = $head;
    while ($fastPtr && $fastPtr->next) {
        $prevPtr = $slowPtr;
        $slowPtr = $slowPtr->next;
        $fastPtr = $fastPtr->next->next;
    }
    if ($prevPtr !== null) $prevPtr->next = null;
    return $slowPtr;
}

🔥 ТОП ВОПРОСОВ С СОБЕСОВ 🔒 База собесов | 🔒 База тестовых

#easy Задача: 108. Convert Sorted Array to Binary Search Tree Дан массив целых чисел nums, элементы которого отсортированы в порядке возрастания. Преобразуйте его в сбалансированное по высоте двоичное дерево поиска. Пример:

Input: nums = [-10,-3,0,5,9]
Output: [0,-3,9,-10,null,5]
Explanation: [0,-10,5,null,-3,null,9] is also accepted:

👨‍💻 Алгоритм: 1️⃣Инициализация функции помощника: Реализуйте функцию помощника helper(left, right), которая строит двоичное дерево поиска (BST) из элементов массива nums между индексами left и right. Если left > right, это означает, что элементов для построения поддерева нет, возвращаем None. 2️⃣Выбор корня и разделение массива: Выберите элемент в середине для корня: p = (left + right) // 2. Инициализируйте корень: root = TreeNode(nums[p]). 3️⃣Рекурсивное построение поддеревьев: Рекурсивно стройте левое поддерево: root.left = helper(left, p - 1). Рекурсивно стройте правое поддерево: root.right = helper(p + 1, right). В качестве результата возвращайте helper(0, len(nums) - 1), начиная с корня дерева. 😎 Решение:

class TreeNode {
    public $val;
    public $left;
    public $right;

    public function __construct($value = 0, $left = null, $right = null) {
        $this->val = $value;
        $this->left = $left;
        $this->right = $right;
    }
}

function sortedArrayToBST($nums) {
    return helper($nums, 0, count($nums) - 1);
}

function helper($nums, $left, $right) {
    if ($left > $right) {
        return null;
    }
    $p = intval(floor(($left + $right) / 2));
    $root = new TreeNode($nums[$p]);
    $root->left = helper($nums, $left, $p - 1);
    $root->right = helper($nums, $p + 1, $right);
    return $root;
}

🔥 ТОП ВОПРОСОВ С СОБЕСОВ 🔒 База собесов | 🔒 База тестовых

🔥Тесты для подготовки к собеседованию🔥 Выбери своё направление: 1. Frontend 2. Python 3. Java 4. Тестировщик QA 5. Data Science 6. DevOps 7. C# 8. С/C++ 9. Golang 10. PHP 11. Kotlin 12. Swift

10$ за техническое собеседование на английском языке: 1. Отправьте запись технического собеседования на английском языке файлом на этот аккаунт 2. Добавьте ссылку на вакансию или пришлите название компании и должность 3. Напишите номер кошелка USDT (Tether) на который отправить 10$ 🛡 Важно: – Запись будет использована только для сбора данных о вопросах – Вы останетесь анонимны – Запись нигде не будет опубликована 🤝 Условия: – Внятный звук, различимая речь – Допустимые профессии: • Любые программисты • DevOps • Тестировщики • Дата сайнтисты • Бизнес/Системные аналитики • Прожекты/Продукты • UX/UI и продукт дизайнеры

📚 Здесь собраны все вопросы, которые могут спросить на собеседовании. Теперь можно легко получить оффер, подготовившись к самым популярным вопросам. Просто выбери своё направление: 1. Python 2. JavaScrtipt / Frontend 3. Java 4. Тестировщик 5. Data Science 6. DevOps 7. C# 8. С/C++ 9. Golang 10. PHP 11. Kotlin 12. Swift

#medium Задача: 107. Binary Tree Level Order Traversal II Дан корень бинарного дерева. Верните обход значений узлов снизу вверх по уровням (то есть слева направо, уровень за уровнем, от листа к корню). Пример:

Input: root = [3,9,20,null,null,15,7]
Output: [[15,7],[9,20],[3]]

👨‍💻 Алгоритм: 1️⃣Инициализируйте список вывода levels. Длина этого списка определяет, какой уровень в данный момент обновляется. Вам следует сравнить этот уровень len(levels) с уровнем узла level, чтобы убедиться, что вы добавляете узел на правильный уровень. Если вы все еще находитесь на предыдущем уровне, добавьте новый уровень, вставив новый список в levels. 2️⃣Добавьте значение узла в последний уровень в levels. 3️⃣Рекурсивно обработайте дочерние узлы, если они не равны None, используя функцию helper(node.left / node.right, level + 1). 😎 Решение:

<?php

class TreeNode {
    public $val = null;
    public $left = null;
    public $right = null;

    public function __construct($value = 0, $left = null, $right = null) {
        $this->val = $value;
        $this->left = $left;
        $this->right = $right;
    }
}

class Solution {
    private $levels = [];

    private function helper($node, $level) {
        if (!$node) return;
        if (!isset($this->levels[$level])) $this->levels[$level] = [];
        array_push($this->levels[$level], $node->val);
        if ($node->left) $this->helper($node->left, $level + 1);
        if ($node->right) $this->helper($node->right, $level + 1);
    }

    public function levelOrderBottom($root) {
        $this->helper($root, 0);
        return array_reverse($this->levels);
    }
}

🔥 ТОП ВОПРОСОВ С СОБЕСОВ 🔒 База собесов | 🔒 База тестовых

#medium Задача: 106. Construct Binary Tree from Inorder and Postorder Traversal Даны два массива целых чисел: inorder и postorder, где inorder — это массив обхода в глубину бинарного дерева слева направо, а postorder — это массив обхода в глубину после обработки всех потомков узла. Постройте и верните соответствующее бинарное дерево. Пример:

Input: inorder = [9,3,15,20,7], postorder = [9,15,7,20,3]
Output: [3,9,20,null,null,15,7]

👨‍💻 Алгоритм: 1️⃣Создайте хэш-таблицу (hashmap) для хранения соответствия значений и их индексов в массиве обхода inorder. 2️⃣Определите вспомогательную функцию helper, которая принимает границы левой и правой части текущего поддерева в массиве inorder. Эти границы используются для проверки, пусто ли поддерево. Если левая граница больше правой (in_left > in_right), то поддерево пустое и функция возвращает None. 3️⃣Выберите последний элемент в массиве обхода postorder в качестве корня. Значение корня имеет индекс index в обходе inorder. Элементы от in_left до index - 1 принадлежат левому поддереву, а элементы от index + 1 до in_right — правому поддереву. Согласно логике обхода postorder, сначала рекурсивно строится правое поддерево helper(index + 1, in_right), а затем левое поддерево helper(in_left, index - 1). Возвращается корень. 😎 Решение:

function buildTree($inorder, $postorder) {
    $idx_map = [];
    $post_idx = count($postorder) - 1;
    $helper = function($in_left, $in_right) use (&$helper, &$postorder, &$idx_map, &$post_idx) {
        if ($in_left > $in_right) return null;
        $root_val = $postorder[$post_idx];
        $root = new TreeNode($root_val);
        $index = $idx_map[$root_val];
        $post_idx--;
        $root->right = $helper($index + 1, $in_right);
        $root->left = $helper($in_left, $index - 1);
        return $root;
    };
    foreach ($inorder as $i => $val) {
        $idx_map[$val] = $i;
    }
    return $helper(0, count($inorder) - 1);
}

🔥 ТОП ВОПРОСОВ С СОБЕСОВ 🔒 База собесов | 🔒 База тестовых

#medium Задача: 105. Construct Binary Tree from Preorder and Inorder Traversal Даны два массива целых чисел: preorder и inorder, где preorder — это результат преордер обхода бинарного дерева, а inorder — результат инордер обхода того же дерева. Постройте и верните бинарное дерево. Пример:

Input: preorder = [3,9,20,15,7], inorder = [9,3,15,20,7]
Output: [3,9,20,null,null,15,7]

👨‍💻 Алгоритм: 1️⃣Создайте хеш-таблицу для записи соотношения значений и их индексов в массиве inorder, чтобы можно было быстро найти позицию корня. 2️⃣Инициализируйте переменную целочисленного типа preorderIndex для отслеживания элемента, который будет использоваться для создания корня. Реализуйте рекурсивную функцию arrayToTree, которая принимает диапазон массива inorder и возвращает построенное бинарное дерево: Если диапазон пуст, возвращается null; Инициализируйте корень элементом preorder[preorderIndex], затем увеличьте preorderIndex; Рекурсивно используйте левую и правую части массива inorder для построения левого и правого поддеревьев. 3️⃣Просто вызовите функцию рекурсии с полным диапазоном массива inorder. 😎 Решение:

function buildTree($preorder, $inorder) {
    static $preorderIndex = 0;
    $inorderIndexMap = [];
    foreach ($inorder as $i => $value) {
        $inorderIndexMap[$value] = $i;
    }
    
    return arrayToTree(0, count($preorder) - 1, $preorder, $inorderIndexMap, $preorderIndex);
}

function arrayToTree($left, $right, &$preorder, &$inorderIndexMap, &$preorderIndex) {
    if ($left > $right) {
        return null;
    }
    
    $rootValue = $preorder[$preorderIndex++];
    $root = new TreeNode($rootValue);
    $root->left = arrayToTree($left, $inorderIndexMap[$rootValue] - 1, $preorder, $inorderIndexMap, $preorderIndex);
    $root->right = arrayToTree($inorderIndexMap[$rootValue] + 1, $right, $preorder, $inorderIndexMap, $preorderIndex);
    return $root;
}

class TreeNode {
    public $val;
    public $left;
    public $right;

    public function __construct($value) {
        $this->val = $value;
        $this->left = null;
        $this->right = null;
    }
}

🔥 ТОП ВОПРОСОВ С СОБЕСОВ 🔒 База собесов | 🔒 База тестовых

#medium Задача: 103. Binary Tree Zigzag Level Order Traversal Дан корень бинарного дерева. Верните обход узлов дерева по уровням в виде зигзага (то есть слева направо, затем справа налево для следующего уровня и чередуйте далее). Пример:

Input: root = [3,9,20,null,null,15,7]
Output: [[3],[20,9],[15,7]]

👨‍💻 Алгоритм: 1️⃣Мы также можем реализовать поиск в ширину (BFS) с использованием одного цикла. Трюк заключается в том, что мы добавляем узлы для посещения в очередь, а узлы разных уровней разделяем с помощью какого-то разделителя (например, пустого узла). Разделитель отмечает конец уровня, а также начало нового уровня. 2️⃣Здесь мы принимаем второй подход, описанный выше. Можно начать с обычного алгоритма BFS, к которому мы добавляем элемент порядка зигзага с помощью deque (двусторонней очереди). 3️⃣Для каждого уровня мы начинаем с пустого контейнера deque, который будет содержать все значения данного уровня. В зависимости от порядка каждого уровня, т.е. либо слева направо, либо справа налево, мы решаем, с какого конца deque добавлять новый элемент. 😎 Решение:

class TreeNode {
    public $val;
    public $left;
    public $right;

    public function __construct($val, $left = null, $right = null) {
        $this->val = $val;
        $this->left = $left;
        $this->right = $right;
    }
}

class Solution {
    function zigzagLevelOrder($root) {
        $result = [];
        if ($root === null) {
            return $result;
        }

        $nodeQueue = new SplQueue();
        $nodeQueue->enqueue($root);
        $nodeQueue->enqueue(null);
        $isOrderLeft = true;
        $levelList = [];

        while (!$nodeQueue->isEmpty()) {
            $currentNode = $nodeQueue->dequeue();

            if ($currentNode !== null) {
                if ($isOrderLeft) {
                    $levelList[] = $currentNode->val;
                } else {
                    array_unshift($levelList, $currentNode->val);
                }

                if ($currentNode->left !== null) {
                    $nodeQueue->enqueue($currentNode->left);
                }
                if ($currentNode->right !== null) {
                    $nodeQueue->enqueue($currentNode->right);
                }
            } else {
                $result[] = $levelList;
                $levelList = [];
                if (!$nodeQueue->isEmpty()) {
                    $nodeQueue->enqueue(null);
                }
                $isOrderLeft = !$isOrderLeft;
            }
        }

        return $result;
    }
}

🔥 ТОП ВОПРОСОВ С СОБЕСОВ 🔒 База собесов | 🔒 База тестовых

#medium Задача: 102. Binary Tree Level Order Traversal Дан корень бинарного дерева. Верните обход узлов дерева по уровням (то есть слева направо, уровень за уровнем). Пример:

Input: root = [3,9,20,null,null,15,7]
Output: [[3],[9,20],[15,7]]

👨‍💻 Алгоритм: 1️⃣Самый простой способ решения задачи — использование рекурсии. Сначала убедимся, что дерево не пустое, а затем рекурсивно вызовем функцию helper(node, level), которая принимает текущий узел и его уровень в качестве аргументов. 2️⃣Эта функция выполняет следующее: Выходной список здесь называется levels, и, таким образом, текущий уровень — это просто длина этого списка len(levels). Сравниваем номер текущего уровня len(levels) с уровнем узла level. Если вы все еще на предыдущем уровне, добавьте новый, добавив новый список в levels. 3️⃣Добавьте значение узла в последний список в levels. Рекурсивно обработайте дочерние узлы, если они не равны None: helper(node.left / node.right, level + 1). 😎 Решение:

class TreeNode {
    public $val;
    public $left;
    public $right;

    public function __construct($val = 0, $left = null, $right = null) {
        $this->val = $val;
        $this->left = $left;
        $this->right = $right;
    }
}

class Solution {
    function levelOrder($root) {
        $levels = [];
        if ($root === null) {
            return $levels;
        }

        $this->helper($root, 0, $levels);
        return $levels;
    }

    private function helper($node, $level, &$levels) {
        if ($node === null) {
            return;
        }
        if (!isset($levels[$level])) {
            $levels[$level] = [];
        }

        $levels[$level][] = $node->val;

        $this->helper($node->left, $level + 1, $levels);
        $this->helper($node->right, $level + 1, $levels);
    }
}

🔥 ТОП ВОПРОСОВ С СОБЕСОВ 🔒 База собесов | 🔒 База тестовых

#easy Задача: 101. Symmetric Tree Дан корень бинарного дерева. Проверьте, является ли это дерево зеркальным отражением самого себя (то есть симметричным относительно своего центра). Пример:

Input: root = [1,2,2,3,4,4,3]
Output: true

👨‍💻 Алгоритм: 1️⃣Дерево симметрично, если левое поддерево является зеркальным отражением правого поддерева. 2️⃣Следовательно, вопрос заключается в том, когда два дерева являются зеркальным отражением друг друга? Два дерева являются зеркальным отражением друг друга, если: - Их корни имеют одинаковое значение. - Правое поддерево каждого дерева является зеркальным отражением левого поддерева другого дерева. 3️⃣Это похоже на человека, смотрящего в зеркало. Отражение в зеркале имеет ту же голову, но правая рука отражения соответствует левой руке настоящего человека и наоборот. Вышеописанное объяснение естественным образом превращается в рекурсивную функцию. 😎 Решение:

class TreeNode {
    public $val;
    public $left;
    public $right;

    public function __construct($val = 0, $left = null, $right = null) {
        $this->val = $val;
        $this->left = $left;
        $this->right = $right;
    }
}

class Solution {
    function isSymmetric($root) {
        return $this->isMirror($root, $root);
    }

    function isMirror($t1, $t2) {
        if ($t1 === null && $t2 === null) {
            return true;
        }
        if ($t1 === null || $t2 === null) {
            return false;
        }
        return ($t1->val == $t2->val) && $this->isMirror($t1->right, $t2->left) && $this->isMirror($t1->left, $t2->right);
    }
}

🔥 ТОП ВОПРОСОВ С СОБЕСОВ 🔒 База собесов | 🔒 База тестовых

#easy Задача: 100. Same Tree Даны корни двух бинарных деревьев p и q. Напишите функцию, чтобы проверить, одинаковы ли они. Два бинарных дерева считаются одинаковыми, если они структурно идентичны, и узлы имеют одинаковые значения. Пример:

Input: p = [1,2,3], q = [1,2,3]
Output: true

👨‍💻 Алгоритм: Самая простая стратегия здесь — использовать рекурсию. Проверьте, не равны ли узлы p и q значению None, и равны ли их значения. Если все проверки пройдены успешно, проделайте то же самое для дочерних узлов рекурсивно. 😎 Решение:

class TreeNode {
    public $val;
    public $left;
    public $right;

    public function __construct($val = 0, $left = null, $right = null) {
        $this->val = $val;
        $this->left = $left;
        $this->right = $right;
    }
}

class Solution {
    function isSameTree($p, $q) {
        if ($p === null && $q === null) {
            return true;
        }
        if ($p === null || $q === null) {
            return false;
        }
        if ($p->val !== $q->val) {
            return false;
        }
        return $this->isSameTree($p->right, $q->right) && $this->isSameTree($p->left, $q->left);
    }
}

🔥 ТОП ВОПРОСОВ С СОБЕСОВ 🔒 База собесов | 🔒 База тестовых