N-ary Tree Leetcode həllinin maksimum dərinliyi

Çətinlik səviyyəsi Asan
Tez-tez soruşulur Amazon google microsoft
alqoritmlər Genişlik İlk Axtarış kodlaşdırma Dərinlik İlk Axtarış müsahibə müsahibə hazırlığı LeetCode LeetCodeSolutions N-ary ağacıBaxılıb 46

Bu problemdə bizə bir N-ary ağacı, yəni qovşaqların 2-dən çox uşağa sahib olmasına imkan verən bir ağac. Ağacın kökündən ən uzaq bir yarpağın dərinliyini tapmaq lazımdır. Buna maksimum dərinlik deyilir. Bir yolun dərinliyinin üzərindəki qovşaqların sayına diqqət yetirin.

misal

       2

  /    |    \

3      4      6

                \
           
                  9
3

Izahat: Dəyəri 9 olan yarpaq kökündən ən uzundur və dərinliyi 3. Beləliklə, 3-ü çap edirik.

      2
  
  /      \

3           6   

        /   |   \

      4     7     9
3

Izahat: Qiyməti 4,7 və 9 olan yarpaqlar kökdən ən uzaq və dərinlikləridir 3. Beləliklə, 3-ü çap edirik.

Yanaşma (Rekursiv)

İkili ağacın maksimum dərinliyi istənilən düyünün sol və sağ uşaqlarında rekursiv funksiyanı çağırmaqla hesablanır. Eynilə, N-ary ağacının olması halında, istənilən düyünün bütün uşaqlarına rekursiv funksiyanı çağıraraq maksimum dərinliyi hesablaya bilərik. Bu yanaşma rekursivdir və ağacdan yalnız bir keçid tələb olunur.

N-ary Tree Leetcode həllinin maksimum dərinliyiPin

Alqoritm

  1. Bir funksiya yaradın maxDepth () bir ağacın maksimum dərinliyini qaytarmaq kök ona ötürülür
  2. If kök boşdur:
    • qayıt 0
  3. Dəyişəni başladın maksimum dərinlik maksimum N-ary ağacının dərinliyini saxlamaq
  4. Hər biri üçün uşaq cari kökün uşaq siyahısında:
    • təyin etmək maximumDepth = max (maxDepth (root.left), maxDepth (root.right))
  5. qayıtmaq maksimum Dərinlik + 1

N-ary Tree Leodcode həllinin maksimum dərinliyinin tətbiqi

C ++ Proqramı

#include <bits/stdc++.h>
using namespace std;

struct Node
{
    int value;
    vector <Node*> children;

    Node(int val)
    {
        value = val;
        children = {};
    }

    Node(int val , vector <Node*> childList)
    {
        value = val;
        children = childList;
    }
};

int maxDepth(Node* root)
{
    if(root == NULL)
        return 0;
    int maximumDepth = 0;
    for(Node* &child : root->children)
        maximumDepth = max(maximumDepth , maxDepth(child));
    return maximumDepth + 1;
}

int main()
{
    Node* root = new Node(2);
    root->children = {new Node(3) , new Node(4) , new Node(5)};
    root->children[2]->children = {new Node(9)};
    cout << maxDepth(root) << '\n';
    return 0;
}

Java Proqramı

import java.lang.Math;

class Node
{
    int value;
    Node[] children;

    Node(int val)
    {
        value = val;
        children = new Node[]{};
    }

    Node(int val , Node[] childList)
    {
        value = val;
        children = childList;
    }
};

class maximum_depth
{
    public static void main(String args[])
    {
        Node root = new Node(2);
        Node[] a = {new Node(3) , new Node(4) , new Node(5)};
        root.children = a;
        Node[] b = {new Node(9)};
        root.children[2].children = b;
        System.out.println(maxDepth(root));
    }

    static int maxDepth(Node root)
    {
        if(root == null)
            return 0;
        int maximumDepth = 0;
        for(int i = 0 ; i < root.children.length ; i++)
            maximumDepth = Math.max(maximumDepth , maxDepth(root.children[i]));
        return maximumDepth + 1;
    }
}
3

N-ary Ağac Leetcode Həllinin Maksimum Dərinliyinin Komplekslik Təhlili

Zamanın mürəkkəbliyi

O (N), N = bütün ağacdan bir dəfə keçdiyimiz zaman N-ary ağacının ölçüsü.

Kosmik Mürəkkəblik

O (N) rekursiv zənglər üçün yaddaşda yığma çərçivələri saxladığımız üçün.

Yanaşma (Iterative)

Düyünləri və onların dərinliklərini kökdən saxlamaq üçün bir yığın və ya növbə istifadə edərək yuxarıdakı prosesi təkrarən edə bilərik. Maksimum dərinlik, bu prosesdən alınan bütün köklərin maksimum dərinliyi olacaqdır. Bu məqsəd üçün bir növbə istifadə edirik və ağacın bütün elementlərini kökündən dərinlikləri ilə birlikdə növbəyə itələyirik. Hər düyünün dərinliyini maksimum dərinliyi ilə müqayisə edirik və yeniləyirik.

Alqoritm

  1. Funksiya yaradın maxDepth () yuxarıdakı yanaşmada müzakirə edildiyi kimi
  2. If kök is sıfır:
    • qayıt 0
  3. Başlanğıc maksimum dərinlik nəticəmizi saxlamaq
  4. Bir növbəni başlatın elementləri ağac düyünlərini və onların dərinliklərini ehtiva edir
  5. Basmaq kök və dərinliyi növbəyə 1 kimi
  6. Isə elementləri boş deyil:
    • Ön nodu və hündürlüyü olduğu kimi götürün önNodeön düyün dərinliyi
    • Bir elementi növbədən kənarlaşdırın
    • If ön düyün dərinliyi is böyük çox maksimum dərinlik
      1. Güncelle maksimumDepth = frontNodeDepth
    • If önNode is boş deyil:
      1. Bütün uşaqlarını dərinliyi ilə növbəyə itələyin ön düyün dərinliyi + 1
  7. qayıtmaq maksimum dərinlik
  8. Nəticəni çap edin

N-ary Tree Leodcode həllinin maksimum dərinliyinin tətbiqi

C ++ Proqramı

#include <bits/stdc++.h>
using namespace std;

struct Node
{
    int value;
    vector <Node*> children;

    Node(int val)
    {
        value = val;
        children = {};
    }

    Node(int val , vector <Node*> childList)
    {
        value = val;
        children = childList;
    }
};

int maxDepth(Node* root)
{
    if(root == NULL)
        return 0;
    int maximumDepth = 0 , frontNodeDepth;

    queue <pair <Node* , int> > elements;
    elements.push({root , 1});
    Node* frontNode;
    while(!elements.empty())
    {
        frontNode = elements.front().first;
        frontNodeDepth = elements.front().second;
        elements.pop();
        if(frontNodeDepth > maximumDepth)
            maximumDepth = frontNodeDepth;

        if(frontNode != NULL)
        {
            for(Node* &child : frontNode->children)
                elements.push({child , frontNodeDepth + 1});
        }
    }

    return maximumDepth;
}

int main()
{
    Node* root = new Node(2);
    root->children = {new Node(3) , new Node(4) , new Node(5)};
    root->children[2]->children = {new Node(9)};
    cout << maxDepth(root) << '\n';
    return 0;
}

Java Proqramı

import java.lang.Math;
import java.util.*;

class Node
{
    int value;
    Node[] children;

    Node(int val)
    {
        value = val;
        children = new Node[]{};
    }

    Node(int val , Node[] childList)
    {
        value = val;
        children = childList;
    }
};

class Pair
{
    Node key;
    int value;
    Pair(Node root , int val)
    {
        key = root;
        value = val;
    }
}

class maximum_depth
{
    public static void main(String args[])
    {
        Node root = new Node(2);
        Node[] a = {new Node(3) , new Node(4) , new Node(5)};
        root.children = a;
        Node[] b = {new Node(9)};
        root.children[2].children = b;
        System.out.println(maxDepth(root));
    }

    static int maxDepth(Node root)
    {
        if(root == null)
            return 0;
        LinkedList <Pair> elements = new LinkedList <>();
        elements.add(new Pair(root , 1));
        Node frontNode;
        int maximumDepth = 0 , frontNodeDepth;

        while(elements.size() > 0)
        {
            frontNode = elements.peek().key;
            frontNodeDepth = elements.peek().value;
            elements.remove();
            if(frontNodeDepth > maximumDepth)
                maximumDepth = frontNodeDepth;

            if(frontNode != null)
            {
                for(int i = 0 ; i < frontNode.children.length ; i++)
                    elements.add(new Pair(frontNode.children[i] , frontNodeDepth + 1));
            }
        }
        return maximumDepth;
    }
}
3

N-ary Ağac Leetcode Həllinin Maksimum Dərinliyinin Komplekslik Təhlili

Zamanın mürəkkəbliyi

O (N) yenə də bütün ağacdan keçdikdə. N = ağacın ölçüsü

Kosmik Mürəkkəblik

O (N) ağacdakı bütün qovşaqları dərinliklərində saxlamaq üçün növbə istifadə etdiyimiz üçün.

Şərh yaz

Translate »
1