Balanslaşdırılmış İkili Ağac Leetcode Həlli

Çətinlik səviyyəsi Asan
Tez-tez soruşulur Amazon google microsoft
alqoritmlər Geyim kodlaşdırma müsahibə müsahibə hazırlığı LeetCode LeetCodeSolutionsBaxılıb 39

A ikili ağac ağacdakı hər düyünün sol və sağ alt ağacının hündürlüyünün fərqi ən çox 1 olduqda Boy balanslıdır. Bu problemdə balanslı ikili ağacın olub olmadığını yoxlayacağıq.

Balanslaşdırılmış İkili Ağac Leetcode HəlliPin

misal

             2
        
          / 
    
        1

      /
 
    4
Not balanced
     1

  /     \

2         3
Balanced

Yanaşma

Bunun üçün düşünmək intuitivdir hər ikili ağacdakı qovşaq, sol və sağ alt ağacların tələb olunan şərti izlədiyini yoxlaya bilərik. Bu "Brute Force”Metodu.

Lakin ağacın taraz olub-olmadığını yoxlamaq üçün yanaşma səbəbi ilə yaxşılaşdırıla bilər Vaxt və məkan mürəkkəbliklər.

Problemi a-da həll edəcəyimiz bir yanaşma izləyirik Bottom-Up qaydada. Bir düyünün alt ağaclarının özü, tarazlı ikili olub olmadığını yoxlayın ağac(ya yox) və eyni zamanda ikili ağacın hündürlüyünü əldə edin, bu da rekursiyadan istifadə edərək ümumiləşdirilə bilər.

Alqoritm (Gücün Gücü)

  1. Kökdən başlayın və ikili ağacdan keçənə qədər davam edin kök olur NULL
  2. Sol və sağ alt ağacların hündürlüyünü istifadə edərək alın hündürlük() funksiyası
    • Fərq çoxdursa '1':
      • yalan qayıt. Ağac balans vəziyyətini təmin etmədiyi üçün
    • Sol və sağ alt ağacların balans vəziyyətini rekursiv olaraq yoxlayın
  3. Nəticəni çap edin

Alqoritm (Optimal)

  1. Ağac varsa boş, balanslı olduğunu deyə bilərik. Əks təqdirdə, digər addımları izləyə bilərik:
  2. "Qaytarılması üçün bir köməkçi funksiyası yaradınboy”Rekursiyadan istifadə edərək cari alt ağacın.
  3. Boy funksiyası qayıdacaq:
    • Balanssız bir ağac olduğunda -1
    • əks halda hündürlük.
  4. Subtree sol və ya sağ alt ağac varsa balanssız, və ya hündürlükləri '1' -dən çox, qayıdış -1-dən çox fərqlənir.
  5. Əks təqdirdə, bu alt ağacın hündürlüyünü aşağıdakı kimi qaytarın: 1 + maks (sol_yüksəklik, sağ_yüksəklik)

Həyata keçirilməsi

Balanslı İkili Ağac Leetcode Həlli C ++ Proqramı

Kobud güc metodu

#include <bits/stdc++.h>
using namespace std;
struct treeNode
{
    int value;
    treeNode *left , *right;
    treeNode(int x)
    {
        value = x;
        left = NULL;
        right = NULL;
    }
};


int height(treeNode* root)
{
    if(root == NULL)
        return 0;
    return max(height(root->left) , height(root->right)) + 1;
}


bool balanced(treeNode* root)
{
    if(root == NULL)
    return true;

    int l = height(root->left) , r = height(root->right);
    //calling height function at every node
    if(abs(l - r) > 1)
        return false;

    return balanced(root->left) && balanced(root->right);
}


int main()
{
    treeNode* root = new treeNode(2);
    root->left = new treeNode(2);
    root->left->left = new treeNode(4);
    
    if(balanced(root))
        cout << "Balanced" << '\n';
    else
        cout << "Not Balanced" << '\n';
    return 0;
}

Optimal metod

#include <bits/stdc++.h>
using namespace std;
struct treeNode
{
    int value;
    treeNode *left , *right;
    treeNode(int x)
    {
        value = x;
        left = NULL;
        right = NULL;
    }
};


int height(treeNode* root)
{
    if(root == NULL)
        return 0;
    int l = height(root->left);
    int r = height(root->right);
    if(l == -1 || r == -1 || abs(l - r) > 1)
        return -1;
    return max(l , r) + 1;
}


bool balanced(treeNode* root)
{
    if(root == NULL)
        return true;

    return (height(root) != -1);
}


int main()
{
    treeNode* root = new treeNode(2);
    root->left = new treeNode(2);
    root->left->left = new treeNode(4);

    if(balanced(root))
        cout << "Balanced" << '\n';
    else
        cout << "Not Balanced" << '\n';
    return 0;
}
Not Balanced

Balanslaşdırılmış İkili Ağac Leetcode Çözümünün Java Proqramı

Brute Force

import java.lang.Math;

class treeNode
{
    int value;
    treeNode left, right;

    public treeNode(int x)
    {
        value= x;
        left = right = null;
    }
}

class balanced_binary_tree
{
    public static int height(treeNode root)
    {
        if(root == null)
            return 0;
        return Math.max(height(root.left) , height(root.right)) + 1;
    }


    public static boolean balanced(treeNode root)
    {
        if(root == null)
            return true;

        int l = height(root.left) , r = height(root.right);
        if(Math.abs(r - l) > 1)
            return false;
        return balanced(root.left) && balanced(root.right);
    }


    public static void main(String args[])
    {
        treeNode root = new treeNode(2);
        root.left = new treeNode(1);
        root.right = new treeNode(3);

        if(balanced(root))
            System.out.println("Balanced");
        else
            System.out.println("Not Balanced");
    }
}

Optimal metod

import java.lang.Math;

class treeNode
{
    int value;
    treeNode left, right;

    public treeNode(int x)
    {
        value= x;
        left = right = null;
    }
}

class balanced_binary_tree
{
    public static int height(treeNode root)
    {
        if(root == null)
            return 0;

        int l = height(root.left);
        int r = height(root.right);

        if(l == -1 || r == -1 || Math.abs(l - r) > 1)
            return -1;

        return Math.max(l , r) + 1;
    }


    public static boolean balanced(treeNode root)
    {
        if(root == null)
            return true;

        return (height(root) != -1);
    }


    public static void main(String args[])
    {
        treeNode root = new treeNode(2);
        root.left = new treeNode(1);
        root.left.left = new treeNode(4);

        if(balanced(root))
            System.out.println("Balanced");
        else
            System.out.println("Not Balanced");
    }
}
Not Balanced

Balanslaşdırılmış İkili Ağac Leetcode həllinin mürəkkəbliyi təhlili

Zamanın mürəkkəbliyi

Brute Force metodu bir zaman mürəkkəbliyinə malikdir O (N * N), ən pis vəziyyətdə (əyilmiş ağac). Bununla birlikdə, optimal yanaşma işləyir O (N) yalnız tək bir pas etdiyimiz zaman.

Kosmik Mürəkkəblik

Hər iki vəziyyətdə də O (N), çünki rekursiya köməkçi yığın boşluğundan istifadə edir.

Şərh yaz

Translate »
1