Рубрики

Как определить, сбалансировано ли бинарное дерево по высоте?

Дерево, у которого нет листьев, намного дальше от корня, чем любой другой лист. Различные схемы балансировки позволяют по-разному определять «гораздо дальше» и разные объемы работы, чтобы удерживать их в равновесии.

Рассмотрим схему выравнивания высоты, в которой необходимо проверить следующие условия, чтобы определить, сбалансировано ли двоичное дерево.
Пустое дерево сбалансировано по высоте. Непустое двоичное дерево T сбалансировано, если:
1) Левое поддерево Т сбалансировано
2) Правое поддерево T сбалансировано
3) Разница между высотой левого поддерева и правого поддерева не более 1.

Вышеуказанная схема выравнивания высоты используется в деревьях AVL. Диаграмма ниже показывает два дерева, одно из которых сбалансировано по высоте, а другое — нет. Второе дерево не сбалансировано по высоте, поскольку высота левого поддерева на 2 больше высоты правого поддерева.

Чтобы проверить, сбалансировано ли дерево по высоте, получите высоту левого и правого поддеревьев. Вернуть true, если разница между высотами не превышает 1, а левое и правое поддеревья сбалансированы, в противном случае вернуть false.

C ++

/ * Программа CPP, чтобы проверить, если
дерево сбалансировано по высоте или нет * /
#include <bits/stdc++.h>

using namespace std;

  
/ * Узел двоичного дерева содержит данные,
указатель на левого ребенка и
указатель на правого ребенка * /

class node {

public:

    int data;

    node* left;

    node* right;

};

  
/ * Возвращает высоту двоичного дерева * /

int height(node* node);

  
/ * Возвращает true, если двоичное дерево
с корнем, поскольку корень сбалансирован по высоте * /

bool isBalanced(node* root)

{

    int lh; / * для высоты левого поддерева * /

    int rh; / * для высоты правого поддерева * /

  

    / * Если дерево пусто, вернуть true * /

    if (root == NULL)

        return 1;

  

    / * Получить высоту левого и правого поддеревьев * /

    lh = height(root->left);

    rh = height(root->right);

  

    if (abs(lh - rh) <= 1 && isBalanced(root->left) && isBalanced(root->right))

        return 1;

  

    / * Если мы достигнем здесь, то

    дерево не сбалансировано по высоте * /

    return 0;

}

  
/ * ПОЛЕЗНЫЕ ФУНКЦИИ ДЛЯ ТЕСТИРОВАНИЯ isBalanced () ФУНКЦИЯ * /

  
/ * возвращает максимум два целых числа * /

int max(int a, int b)

{

    return (a >= b) ? a : b;

}

  
/ * Функция вычисляет «высоту»
дерева. Высота это число
узлы вдоль самого длинного пути от
корневой узел до самого дальнего конечного узла. * /

int height(node* node)

{

    / * базовое дерево пусто * /

    if (node == NULL)

        return 0;

  

    / * Если дерево не пустое, то

    высота = 1 + максимум слева

        высота и правая высота * /

    return 1 + max(height(node->left),

                   height(node->right));

}

  
/ * Вспомогательная функция, которая выделяет
новый узел с заданными данными
и NULL левый и правый указатели. * /

node* newNode(int data)

{

    node* Node = new node();

    Node->data = data;

    Node->left = NULL;

    Node->right = NULL;

  

    return (Node);

}

  
// Код драйвера

int main()

{

    node* root = newNode(1);

    root->left = newNode(2);

    root->right = newNode(3);

    root->left->left = newNode(4);

    root->left->right = newNode(5);

    root->left->left->left = newNode(8);

  

    if (isBalanced(root))

        cout << "Tree is balanced";

    else

        cout << "Tree is not balanced";

    return 0;

}

  
// Этот код предоставлен rathbhupendra

С

/ * C программа для проверки, сбалансировано ли дерево по высоте или нет * /
#include <stdio.h>
#include <stdlib.h>
#define bool int

  
/ * Узел двоичного дерева содержит данные, указатель на левого потомка

   и указатель на правого ребенка * /

struct node {

    int data;

    struct node* left;

    struct node* right;

};

  
/ * Возвращает высоту двоичного дерева * /

int height(struct node* node);

  
/ * Возвращает true, если двоичное дерево с корнем в качестве корня сбалансировано по высоте * /

bool isBalanced(struct node* root)

{

    int lh; / * для высоты левого поддерева * /

    int rh; / * для высоты правого поддерева * /

  

    / * Если дерево пусто, вернуть true * /

    if (root == NULL)

        return 1;

  

    / * Получить высоту левого и правого поддеревьев * /

    lh = height(root->left);

    rh = height(root->right);

  

    if (abs(lh - rh) <= 1 && isBalanced(root->left) && isBalanced(root->right))

        return 1;

  

    / * Если мы достигаем здесь, то дерево не сбалансировано по высоте * /

    return 0;

}

  
/ * ПОЛЕЗНЫЕ ФУНКЦИИ ДЛЯ ТЕСТИРОВАНИЯ isBalanced () ФУНКЦИЯ * /

  
/ * возвращает максимум два целых числа * /

int max(int a, int b)

{

    return (a >= b) ? a : b;

}

  
/ * Функция вычисляет «высоту» дерева. Высота это

    количество узлов вдоль самого длинного пути от корневого узла

    вплоть до самого дальнего листового узла. * /

int height(struct node* node)

{

    / * базовое дерево пусто * /

    if (node == NULL)

        return 0;

  

    / * Если дерево не пустое, то высота = 1 + максимум слева

      высота и правая высота * /

    return 1 + max(height(node->left), height(node->right));

}

  
/ * Вспомогательная функция, которая выделяет новый узел с

   данные даны и NULL левый и правый указатели. * /

struct node* newNode(int data)

{

    struct node* node = (struct node*)

        malloc(sizeof(struct node));

    node->data = data;

    node->left = NULL;

    node->right = NULL;

  

    return (node);

}

  

int main()

{

    struct node* root = newNode(1);

    root->left = newNode(2);

    root->right = newNode(3);

    root->left->left = newNode(4);

    root->left->right = newNode(5);

    root->left->left->left = newNode(8);

  

    if (isBalanced(root))

        printf("Tree is balanced");

    else

        printf("Tree is not balanced");

  

    getchar();

    return 0;

}

Джава

/ * Java-программа для определения, является ли двоичное дерево

   сбалансированный по высоте или нет * /

  
/ * Узел двоичного дерева содержит данные, указатель на левого потомка,

   и указатель на правого ребенка * /

class Node {

    int data;

    Node left, right;

    Node(int d)

    {

        data = d;

        left = right = null;

    }

}

  

class BinaryTree {

    Node root;

  

    / * Возвращает true, если двоичное дерево с корнем в качестве корня сбалансировано по высоте * /

    boolean isBalanced(Node node)

    {

        int lh; / * для высоты левого поддерева * /

  

        int rh; / * для высоты правого поддерева * /

  

        / * Если дерево пусто, вернуть true * /

        if (node == null)

            return true;

  

        / * Получить высоту левого и правого поддеревьев * /

        lh = height(node.left);

        rh = height(node.right);

  

        if (Math.abs(lh - rh) <= 1

            && isBalanced(node.left)

            && isBalanced(node.right))

            return true;

  

        / * Если мы достигаем здесь, то дерево не сбалансировано по высоте * /

        return false;

    }

  

    / * ПОЛЕЗНЫЕ ФУНКЦИИ ДЛЯ ТЕСТИРОВАНИЯ isBalanced () ФУНКЦИЯ * /

    / * Функция вычисляет «высоту» дерева. Высота это

        количество узлов вдоль самого длинного пути от корневого узла

        вплоть до самого дальнего листового узла. * /

    int height(Node node)

    {

        / * базовое дерево пусто * /

        if (node == null)

            return 0;

  

        / * Если дерево не пустое, то высота = 1 + максимум слева

         высота и правая высота * /

        return 1 + Math.max(height(node.left), height(node.right));

    }

  

    public static void main(String args[])

    {

        BinaryTree tree = new BinaryTree();

        tree.root = new Node(1);

        tree.root.left = new Node(2);

        tree.root.right = new Node(3);

        tree.root.left.left = new Node(4);

        tree.root.left.right = new Node(5);

        tree.root.left.left.left = new Node(8);

  

        if (tree.isBalanced(tree.root))

            System.out.println("Tree is balanced");

        else

            System.out.println("Tree is not balanced");

    }

}

  
// Этот код предоставлен Mayank Jaiswal (mayank_24)

python3

«»»
Программа на Python3, чтобы проверить, сбалансировано ли дерево
«»»
# Узел двоичного дерева

class Node:

    # Конструктор для создания нового узла

    def __init__(self, data):

        self.data = data

        self.left = None

        self.right = None

  
# функция для определения высоты двоичного дерева

def height(root):

      

    # базовое условие, когда двоичное дерево пусто

    if root is None:

        return 0

    return max(height(root.left), height(root.right)) + 1

  
# функция, чтобы проверить, сбалансировано ли дерево или нет

def isBalanced(root):

      

    # Базовое состояние

    if root is None:

        return True

  

    # для левой и правой высоты поддерева

    lh = height(root.left)

    rh = height(root.right)

  

    # допустимые значения для (lh - rh): 1, -1, 0

    if (abs(lh - rh) <= 1) and isBalanced(

    root.left) is True and isBalanced( root.right) is True:

        return True

  

    # если мы достигаем здесь означает, что дерево не

    # сбалансированное по высоте дерево

    return False

  
# Функция драйвера для проверки вышеуказанной функции

root = Node(1)

root.left = Node(2)

root.right = Node(3)

root.left.left = Node(4)

root.left.right = Node(5)

root.left.left.left = Node(8)

if isBalanced(root):

    print("Tree is balanced")

else:

    print("Tree is not balanced")

  
# Этот код предоставлен Shweta Singh

C #

using System;

  
/ * C # программа для определения, является ли двоичное дерево
сбалансированный по высоте или нет * /

  
/ * Узел двоичного дерева содержит данные, указатель на левого потомка,
и указатель на правого ребенка * /

public class Node {

    public int data;

    public Node left, right;

    public Node(int d)

    {

        data = d;

        left = right = null;

    }

}

  

public class BinaryTree {

    public Node root;

  

    / * Возвращает true, если двоичное дерево с корнем в виде

    корень сбалансирован по высоте * /

    public virtual bool isBalanced(Node node)

    {

        int lh; // для высоты левого поддерева

  

        int rh; // для высоты правого поддерева

  

        / * Если дерево пусто, вернуть true * /

        if (node == null) {

            return true;

        }

  

        / * Получить высоту левого и правого поддеревьев * /

        lh = height(node.left);

        rh = height(node.right);

  

        if (Math.Abs(lh - rh) <= 1 && isBalanced(node.left)

            && isBalanced(node.right)) {

            return true;

        }

  

        / * Если мы достигаем здесь, то дерево не сбалансировано по высоте * /

        return false;

    }

  

    / * ПОЛЕЗНЫЕ ФУНКЦИИ ДЛЯ ТЕСТИРОВАНИЯ isBalanced () ФУНКЦИЯ * /

    / * Функция вычисляет «высоту» дерева. Высота это

        количество узлов вдоль самого длинного пути от корневого узла

        вплоть до самого дальнего листового узла. * /

    public virtual int height(Node node)

    {

        / * базовое дерево пусто * /

        if (node == null) {

            return 0;

        }

  

        / * Если дерево не пустое, то высота = 1 + максимум слева

        высота и правая высота * /

        return 1 + Math.Max(height(node.left), height(node.right));

    }

  

    public static void Main(string[] args)

    {

        BinaryTree tree = new BinaryTree();

        tree.root = new Node(1);

        tree.root.left = new Node(2);

        tree.root.right = new Node(3);

        tree.root.left.left = new Node(4);

        tree.root.left.right = new Node(5);

        tree.root.left.left.left = new Node(8);

  

        if (tree.isBalanced(tree.root)) {

            Console.WriteLine("Tree is balanced");

        }

        else {

            Console.WriteLine("Tree is not balanced");

        }

    }

}

  
// Этот код предоставлен Shrikant13


Выход:

Tree is not balanced

Сложность времени: O (n ^ 2) Наихудший случай возникает в случае перекошенного дерева.

Оптимизированная реализация: вышеуказанную реализацию можно оптимизировать, вычисляя высоту в той же рекурсии, а не вызывая функцию height () по отдельности. Спасибо Амару за предложение этой оптимизированной версии. Эта оптимизация уменьшает сложность времени до O (n).

C ++

/ * C ++ программа для проверки, если дерево
сбалансирован по высоте или нет * /
#include <bits/stdc++.h>

using namespace std;

#define bool int

  
/ * Узел двоичного дерева содержит данные,
указатель на левого ребенка и
указатель на правого ребенка * /

class node {

public:

    int data;

    node* left;

    node* right;

};

  
/ * Функция возвращает true, если root
сбалансированный иначе ложь второй параметр
это хранить высоту дерева. Первоначально,
нам нужно передать указатель на местоположение с
значение как 0. Мы также можем написать обертку
над этой функцией * /

bool isBalanced(node* root, int* height)

{

  

    / * lh -> Высота левого поддерева

    rh -> Высота правого поддерева * /

    int lh = 0, rh = 0;

  

    / * l будет true, если левое поддерево сбалансировано

    и r будет истинным, если правильное поддерево сбалансировано * /

    int l = 0, r = 0;

  

    if (root == NULL) {

        *height = 0;

        return 1;

    }

  

    / * Получить высоты левого и правого поддеревьев в lh и rh

    И сохраните возвращенные значения в l и r * /

    l = isBalanced(root->left, &lh);

    r = isBalanced(root->right, &rh);

  

    / * Высота текущего узла - максимум высот слева и

    правильные поддеревья плюс 1 * /

    *height = (lh > rh ? lh : rh) + 1;

  

    / * Если разница между высотой слева и справа

    поддеревьев больше 2, тогда этот узел не сбалансирован

    так верните 0 * /

    if ((lh - rh >= 2) || (rh - lh >= 2))

        return 0;

  

    / * Если этот узел сбалансирован и левое и правое поддеревья

    сбалансированы и возвращают true * /

    else

        return l && r;

}

  
/ * ПОЛЕЗНЫЕ ФУНКЦИИ ДЛЯ ТЕСТИРОВАНИЯ isBalanced () ФУНКЦИЯ * /

  
/ * Вспомогательная функция, которая выделяет новый узел с
данные даны и NULL левый и правый указатели. * /

node* newNode(int data)

{

    node* Node = new node();

    Node->data = data;

    Node->left = NULL;

    Node->right = NULL;

  

    return (Node);

}

  
// Код драйвера

int main()

{

    int height = 0;

  

    / * Построенное двоичное дерево

            1

            / /

            2 3

            ///

            4 5 6

            /

            7

    * /

    node* root = newNode(1);

    root->left = newNode(2);

    root->right = newNode(3);

    root->left->left = newNode(4);

    root->left->right = newNode(5);

    root->right->left = newNode(6);

    root->left->left->left = newNode(7);

  

    if (isBalanced(root, &height))

        cout << "Tree is balanced";

    else

        cout << "Tree is not balanced";

  

    return 0;

}

  
// Это код, предоставленный rathbhupendra

С

/ * C программа для проверки, сбалансировано ли дерево по высоте или нет * /
#include <stdio.h>
#include <stdlib.h>
#define bool int

  
/ * Узел двоичного дерева содержит данные, указатель на левого потомка

   и указатель на правого ребенка * /

struct node {

    int data;

    struct node* left;

    struct node* right;

};

  
/ * Функция возвращает true, если root сбалансирован, иначе false

   Второй параметр - хранить высоту дерева.

   Изначально нам нужно передать указатель на местоположение со значением

   как 0. Мы также можем написать обертку над этой функцией * /

bool isBalanced(struct node* root, int* height)

{

    / * lh -> Высота левого поддерева

     rh -> Высота правого поддерева * /

    int lh = 0, rh = 0;

  

    / * l будет true, если левое поддерево сбалансировано

    и r будет истинным, если правильное поддерево сбалансировано * /

    int l = 0, r = 0;

  

    if (root == NULL) {

        *height = 0;

        return 1;

    }

  

    / * Получить высоты левого и правого поддеревьев в lh и rh

    И сохраните возвращенные значения в l и r * /

    l = isBalanced(root->left, &lh);

    r = isBalanced(root->right, &rh);

  

    / * Высота текущего узла - максимум высот слева и

     правильные поддеревья плюс 1 * /

    *height = (lh > rh ? lh : rh) + 1;

  

    / * Если разница между высотой слева и справа

     поддеревьев больше 2, тогда этот узел не сбалансирован

     так верните 0 * /

    if ((lh - rh >= 2) || (rh - lh >= 2))

        return 0;

  

    / * Если этот узел сбалансирован и левое и правое поддеревья

    сбалансированы и возвращают true * /

    else

        return l && r;

}

  
/ * ПОЛЕЗНЫЕ ФУНКЦИИ ДЛЯ ТЕСТИРОВАНИЯ isBalanced () ФУНКЦИЯ * /

  
/ * Вспомогательная функция, которая выделяет новый узел с

   данные даны и NULL левый и правый указатели. * /

struct node* newNode(int data)

{

    struct node* node = (struct node*)

        malloc(sizeof(struct node));

    node->data = data;

    node->left = NULL;

    node->right = NULL;

  

    return (node);

}

  
// Код драйвера

int main()

{

    int height = 0;

  

    / * Построенное двоичное дерево

             1

           / /

         2 3

       ///

     4 5 6

    /

   7

  * /

    struct node* root = newNode(1);

    root->left = newNode(2);

    root->right = newNode(3);

    root->left->left = newNode(4);

    root->left->right = newNode(5);

    root->right->left = newNode(6);

    root->left->left->left = newNode(7);

  

    if (isBalanced(root, &height))

        printf("Tree is balanced");

    else

        printf("Tree is not balanced");

  

    getchar();

    return 0;

}

Джава

/ * Java-программа для определения, является ли двоичное дерево

   сбалансированный по высоте или нет * /

  
/ * Узел двоичного дерева содержит данные, указатель на левого потомка,

   и указатель на правого ребенка * /

class Node {

  

    int data;

    Node left, right;

  

    Node(int d)

    {

        data = d;

        left = right = null;

    }

}

  
// Класс-обертка, используемый для изменения высоты
// рекурсивные вызовы.

class Height {

    int height = 0;

}

  

class BinaryTree {

  

    Node root;

  

    / * Возвращает true, если двоичное дерево с корнем в качестве корня сбалансировано по высоте * /

    boolean isBalanced(Node root, Height height)

    {

        / * Если дерево пусто, вернуть true * /

        if (root == null) {

            height.height = 0;

            return true;

        }

  

        / * Получить высоты левого и правого поддеревьев * /

        Height lheight = new Height(), rheight = new Height();

        boolean l = isBalanced(root.left, lheight);

        boolean r = isBalanced(root.right, rheight);

        int lh = lheight.height, rh = rheight.height;

  

        / * Высота текущего узла макс. Высот

           левое и правое поддеревья плюс 1 * /

        height.height = (lh > rh ? lh : rh) + 1;

  

        / * Если разница между высотой слева и справа

           поддеревьев больше 2, тогда этот узел не сбалансирован

           так верните 0 * /

        if ((lh - rh >= 2) || (rh - lh >= 2))

            return false;

  

        / * Если этот узел сбалансирован и левое и правое поддеревья

           сбалансированы и возвращают true * /

        else

            return l && r;

    }

  

    public static void main(String args[])

    {

        Height height = new Height();

  

        / * Построенное двоичное дерево

                   1

                 / /

                2 3

              ///

            4 5 6

            /

           7 * /

        BinaryTree tree = new BinaryTree();

        tree.root = new Node(1);

        tree.root.left = new Node(2);

        tree.root.right = new Node(3);

        tree.root.left.left = new Node(4);

        tree.root.left.right = new Node(5);

        tree.root.right.right = new Node(6);

        tree.root.left.left.left = new Node(7);

  

        if (tree.isBalanced(tree.root, height))

            System.out.println("Tree is balanced");

        else

            System.out.println("Tree is not balanced");

    }

}

  
// Этот код предоставлен Mayank Jaiswal (mayank_24)

python3

«»»
Программа Python3 для проверки, является ли двоичное дерево
Высота сбалансирован
«»»

  
# Узел двоичного дерева

class Node:

      

    # конструктор для создания узла

    # двоичное дерево

    def __init__(self, data):

        self.data = data

        self.left = self.right = None

  
# служебный класс для передачи объекта высоты

class Height:

    def __init__(self):

        self.height = 0

  
# вспомогательная функция для проверки бинарности
# дерево сбалансировано по высоте

def isBalanced(root, height):

      

    # lh и rh для сохранения высоты

    # левое и правое поддерево

    lh = Height()

    rh = Height()

  

    # Базовое условие, когда дерево

    # пустое возвращение true

    if root is None:

        return True

  

    # l и r используются для проверки, если осталось

    # и правое поддерево сбалансированы

    l = isBalanced(root.left, lh)

    r = isBalanced(root.right, rh)

  

    # высота дерева не более

    # высота левого поддерева и

    # высота правого поддерева плюс 1

    height.height = max(lh.height, rh.height) + 1

  

    if abs(lh.height - rh.height) <= 1:

        return l and r

  

    # если мы доберемся сюда, то дерево

    # не сбалансирован

    return False

  
# Функция драйвера для проверки вышеуказанной функции
«»»
Построенное двоичное дерево

            1

        / /

        2 3

    ///

    4 5 6/7

«»»
# сохранить высоту дерева при обходе

height = Height()

  

root = Node(1)

root.left = Node(2)

root.right = Node(3)

root.left.left = Node(4)

root.left.right = Node(5)

root.right.left = Node(6)

root.left.left.left = Node(7)

  

if isBalanced(root, height):

    print('Tree is balanced')

else:

    print('Tree is not balanced')

  
# Этот код предоставлен Shweta Singh

C #

using System;

  
/ * C # программа для определения, является ли двоичное дерево

   сбалансированный по высоте или нет * /

  
/ * Узел двоичного дерева содержит данные, указатель на левого потомка,

   и указатель на правого ребенка * /

public class Node {

  

    public int data;

    public Node left, right;

  

    public Node(int d)

    {

        data = d;

        left = right = null;

    }

}

  
// Класс-обертка, используемый для изменения высоты
// рекурсивные вызовы.

public class Height {

    public int height = 0;

}

  

public class BinaryTree {

  

    public Node root;

  

    / * Возвращает true, если двоичное дерево с корнем в качестве корня сбалансировано по высоте * /

    public virtual bool isBalanced(Node root, Height height)

    {

        / * Если дерево пусто, вернуть true * /

        if (root == null) {

            height.height = 0;

            return true;

        }

  

        / * Получить высоты левого и правого поддеревьев * /

        Height lheight = new Height(), rheight = new Height();

        bool l = isBalanced(root.left, lheight);

        bool r = isBalanced(root.right, rheight);

        int lh = lheight.height, rh = rheight.height;

  

        / * Высота текущего узла макс. Высот

           левое и правое поддеревья плюс 1 * /

        height.height = (lh > rh ? lh : rh) + 1;

  

        / * Если разница между высотой слева и справа

           поддеревьев больше 2, тогда этот узел не сбалансирован

           так верните 0 * /

        if ((lh - rh >= 2) || (rh - lh >= 2)) {

            return false;

        }

  

        / * Если этот узел сбалансирован и левое и правое поддеревья

           сбалансированы и возвращают true * /

        else {

            return l && r;

        }

    }

  

    / * Функция вычисляет «высоту» дерева. Высота это

        количество узлов вдоль самого длинного пути от корневого узла

        вплоть до самого дальнего листового узла. * /

    public virtual int height(Node node)

    {

        / * базовое дерево пусто * /

        if (node == null) {

            return 0;

        }

  

        / * Если дерево не пустое, то высота = 1 + максимум слева

         высота и правая высота * /

        return 1 + Math.Max(height(node.left), height(node.right));

    }

  

    public static void Main(string[] args)

    {

        Height height = new Height();

  

        / * Построенное двоичное дерево

                   1

                 / /

                2 3

              ///

            4 5 6

            /

           7 * /

        BinaryTree tree = new BinaryTree();

        tree.root = new Node(1);

        tree.root.left = new Node(2);

        tree.root.right = new Node(3);

        tree.root.left.left = new Node(4);

        tree.root.left.right = new Node(5);

        tree.root.right.right = new Node(6);

        tree.root.left.left.left = new Node(7);

  

        if (tree.isBalanced(tree.root, height)) {

            Console.WriteLine("Tree is balanced");

        }

        else {

            Console.WriteLine("Tree is not balanced");

        }

    }

}

  
// Этот код предоставлен Shrikant13


Выход

Tree is balanced

Сложность времени: O (n)

Спрашивается в: Amazon , Belzabar , Goldman Sachs , InMobi , Intel , Microsoft , Paytm , Synopsys , Walmart , Zillious

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

Рекомендуемые посты:

Как определить, сбалансировано ли бинарное дерево по высоте?

0.00 (0%) 0 votes