leetcode\AverageOfLevelsInBinaryTree

Complexity

Total Complexity

16

Size/Duplication

Total Lines	52
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

3 Methods

Rating	Name	Duplication	Size	Complexity
A	dfs()	0	11	4
B	averageOfLevels()	0	26	10
A	averageOfLevels2()	0	9	2

<?php

declare(strict_types=1);

namespace leetcode;

use leetcode\util\TreeNode;

class AverageOfLevelsInBinaryTree
{
    public static function averageOfLevels(TreeNode $root): array
    {
        if (!$root) {

$root is of type leetcode\util\TreeNode, thus it always evaluated to true.

            return [];
        }
        $ans = $queue = [];

The assignment to $queue is dead and can be removed.

        $queue = [$root];
        while ($queue) {
            [$curr, $n] = [[], count($queue)];
            for ($i = 0; $i < $n; $i++) {
                $node = array_shift($queue);
                if ($node instanceof TreeNode && $node->val) {
                    array_push($curr, $node->val);
                    if ($node->left && $node->left->val) {
                        array_push($queue, $node->left);
                    }
                    if ($node->right && $node->right->val) {
                        array_push($queue, $node->right);
                    }
                }
            }
            $val = round(array_sum($curr) / $n, 2);
            array_push($ans, $val);
        }

        return $ans;
    }

    public static function averageOfLevels2(TreeNode $root): array
    {
        if (!$root) {

$root is of type leetcode\util\TreeNode, thus it always evaluated to true.

            return [];
        }
        $ans = [];
        self::dfs($root, 0, $ans);

        return $ans;
    }

    private static function dfs(?TreeNode $node, int $depth, array & $ans): void
    {
        if ($node instanceof TreeNode && $node->val) {
            if ($depth === count($ans)) {
                array_push($ans, round($node->val, 2));
            } else {
                $curr = [$ans[$depth], $node->val];
                $ans[$depth] = round(array_sum($curr) / count($curr), 2);
            }
            self::dfs($node->left, $depth + 1, $ans);
            self::dfs($node->right, $depth + 1, $ans);
        }
    }
}