Рубрики

Идеальный двоичный древовидный порядок обхода порядка

Деревья

Дано совершенное двоичное дерево, как показано ниже:
(нажмите на изображение, чтобы получить четкое представление)

Распечатайте порядок уровней узлов следующим определенным образом:

  1 2 3 4 7 5 6 8 15 9 14 10 13 11 12 16 31 17 30 18 29 19 28 20 27 21 26  22 25 23 24

т.е. печатать узлы в порядке уровней, но узлы должны быть слева и справа поочередно. Здесь 1- й и 2- й уровни тривиальны.
В то время как 3- й уровень: 4 (слева), 7 (справа), 5 (слева), 6 (справа) печатаются.
В то время как 4- й уровень: 8 (слева), 15 (справа), 9 (слева), 14 (справа), .. печатаются.
В то время как 5- й уровень: 16 (слева), 31 (справа), 17 (слева), 30 (справа), .. печатаются.

Мы настоятельно рекомендуем свернуть ваш браузер и попробовать это в первую очередь.

В стандартном уровне заказа Traversal , мы епдиеий корень в очереди 1 — го, то из очереди одного узла из очереди, процесс (печать) он, епдиеяя своих ребенок в очередь. Мы продолжаем делать это, пока очередь не опустеет.

Подход 1:
Здесь мы также можем выполнить стандартный порядок обхода порядка, но вместо прямой печати узлов мы должны хранить узлы текущего уровня во временном массиве или списке 1- го списка, а затем брать узлы с альтернативных концов (слева и справа) и печатать узлы. Продолжайте повторять это для всех уровней.
Этот подход требует больше памяти, чем стандартный обход.

Подход 2:
Идея прохождения стандартного уровня здесь немного изменится. Вместо обработки ОДНОГО узла за раз, мы будем обрабатывать ДВА узла за раз. И в то время как толкая ребенок в очередь, порядок Епдиеего будет: левый ребенок 1 — го узла, 2 правых дочерним Н.Д. узла, право ребенок 1 — го узла и 2 — й левого потомка узла.

C ++

/ * C ++ программа для обхода специального порядка * /
#include <iostream>
#include <queue>

using namespace std;

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

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

struct Node

{

    int data;

    Node *left;

    Node *right;

};

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

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

Node *newNode(int data)

{

    Node *node = new Node;

    node->data = data;

    node->right = node->left = NULL;

    return node;

}

  
/ * Если дано идеальное двоичное дерево, выведите его узлы в

   уровень порядка * /

void printSpecificLevelOrder(Node *root)

{

    if (root == NULL)

        return;

  

    // Сначала распечатаем корень и следующий уровень

    cout << root->data;

  

    // / Так как это идеальное бинарное дерево, право не проверяется

    if (root->left != NULL)

      cout << " " << root->left->data << " " << root->right->data;

  

    // Делаем больше, если на следующем уровне есть узлы

    // дано идеальное бинарное дерево

    if (root->left->left == NULL)

        return;

  

    // Создаем очередь и ставим в очередь левого и правого потомка root

    queue <Node *> q;

    q.push(root->left);

    q.push(root->right);

  

    // Мы обрабатываем два узла одновременно, поэтому нам нужны две переменные

    // хранить два передних элемента очереди

    Node *first = NULL, *second = NULL;

  

    // цикл обхода

    while (!q.empty())

    {

       // извлекаем два элемента из очереди

       first = q.front();

       q.pop();

       second = q.front();

       q.pop();

  

       // выводим потомки первого и второго в обратном порядке

       cout << " " << first->left->data << " " << second->right->data;

       cout << " " << first->right->data << " " << second->left->data;

  

       // Если у первого и второго есть внуки, поставьте их в очередь

       // в обратном порядке

       if (first->left->left != NULL)

       {

           q.push(first->left);

           q.push(second->right);

           q.push(first->right);

           q.push(second->left);

       }

    }

}

  
/ * Программа драйвера для проверки вышеуказанных функций * /

int main()

{

    // Совершенное бинарное дерево высоты 4

    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->right->right = newNode(7);

  

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

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

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

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

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

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

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

    root->right->right->right  = newNode(15);

  

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    root->right->right->right->right  = newNode(31);

  

    cout << "Specific Level Order traversal of binary tree is \n";

    printSpecificLevelOrder(root);

  

    return 0;

}

Джава

// Java-программа для обхода порядка специального уровня

   

import java.util.LinkedList;

import java.util.Queue;

   
/ * Класс, содержащий левого и правого потомка текущего

   значение узла и ключа * /

class Node 

{

    int data;

    Node left, right;

   

    public Node(int item) 

    {

        data = item;

        left = right = null;

    }

}

   

class BinaryTree 

{

    Node root;

   

    / * Если дано идеальное двоичное дерево, выведите его узлы в

       уровень порядка * /

    void printSpecificLevelOrder(Node node) 

    {

        if (node == null)

            return;

   

        // Сначала распечатаем корень и следующий уровень

        System.out.print(node.data);

   

        // Так как это идеальное двоичное дерево, право не проверяется

        if (node.left != null)

            System.out.print(" " + node.left.data + " " + node.right.data);

   

        // Делаем больше, если на следующем уровне есть узлы

        // дано идеальное бинарное дерево

        if (node.left.left == null)

            return;

   

        // Создаем очередь и ставим в очередь левого и правого потомка root

        Queue<Node> q = new LinkedList<Node>();

        q.add(node.left);

        q.add(node.right);

   

        // Мы обрабатываем два узла одновременно, поэтому нам нужны две переменные

        // хранить два передних элемента очереди

        Node first = null, second = null;

   

        // цикл обхода

        while (!q.isEmpty()) 

        {

            // извлекаем два элемента из очереди

            first = q.peek();

            q.remove();

            second = q.peek();

            q.remove();

   

            // выводим потомки первого и второго в обратном порядке

            System.out.print(" " + first.left.data + " " +second.right.data);

            System.out.print(" " + first.right.data + " " +second.left.data);

   

            // Если у первого и второго есть внуки, поставьте их в очередь

            // в обратном порядке

            if (first.left.left != null) 

            {

                q.add(first.left);

                q.add(second.right);

                q.add(first.right);

                q.add(second.left);

            }

        }

    }

   

    // Программа драйвера для проверки вышеуказанных функций

    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.right.left = new Node(6);

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

   

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

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

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

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

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

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

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

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

   

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   

        System.out.println("Specific Level Order traversal of binary" 

                                                            +"tree is ");

        tree.printSpecificLevelOrder(tree.root);

    }

}

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

питон

# Программа Python для обхода по специальному заказу

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

class Node:

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

    def __init__(self, key):

        self.data = key

        self.left = None

        self.right = None

  
# При наличии идеального двоичного дерева выведите его узел в
# конкретный заказ

def printSpecificLevelOrder(root):

    if root is None:

        return

      

    # Давайте сначала напечатаем root и следующий уровень

    print root.data,

      

    # Так как это идеальное бинарное дерево,

    # один из узлов необходимо проверить

    if root.left is not None :

        print root.left.data,

        print root.right.data,

      

    # Делайте что-нибудь еще, если есть узлы на следующем уровне

    # в заданном совершенном двоичном дереве

    if root.left.left is None:

        return

  

    # Создать очередь и поставить в очередь влево и вправо

    # дети корня

    q = [] 

    q.append(root.left)

    q.append(root.right)

      

    # Мы обрабатываем два узла одновременно, поэтому нам нужно

    # две переменные для обработки двух первых элементов очереди

    first = None

    second = None

     

    # Цикл обхода

    while(len(q) > 0):

  

        # Поп две вещи из очереди

        first = q.pop(0)

        second = q.pop(0)

  

        # Печать детей первого и второго в обратном порядке

        print first.left.data,

        print second.right.data,

        print first.right.data,

        print second.left.data,

          

        # Если у первого и второго есть внуки,

        # ставить их в очередь в обратном порядке

        if first.left.left is not None:

            q.append(first.left)

            q.append(second.right)

            q.append(first.right)

            q.append(second.left)

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

  
# Идеальное бинарное дерево высоты 4

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.right.right = Node(7)

   

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

root.left.left.right  = Node(9)

root.left.right.left  = Node(10)

root.left.right.right  = Node(11)

root.right.left.left  = Node(12)

root.right.left.right  = Node(13)

root.right.right.left  = Node(14)

root.right.right.right  = Node(15)

   

root.left.left.left.left  = Node(16)

root.left.left.left.right  = Node(17)

root.left.left.right.left  = Node(18)

root.left.left.right.right  = Node(19)

root.left.right.left.left  = Node(20)

root.left.right.left.right  = Node(21)

root.left.right.right.left  = Node(22)

root.left.right.right.right  = Node(23)

root.right.left.left.left  = Node(24)

root.right.left.left.right  = Node(25)

root.right.left.right.left  = Node(26)

root.right.left.right.right  = Node(27)

root.right.right.left.left  = Node(28)

root.right.right.left.right  = Node(29)

root.right.right.right.left  = Node(30)

root.right.right.right.right  = Node(31)

   

print "Specific Level Order traversal of binary tree is"

printSpecificLevelOrder(root);

   
# Этот код предоставлен Nikhil Kumar Singh (nickzuck_007)

C #

// C # программа для специального уровня
// обход заказа

using System;

using System.Collections.Generic;

  
/ * Класс, содержащий левый и правый
дочерний элемент текущего узла и значение ключа * /

public class Node

{

    public int data;

    public Node left, right;

  

    public Node(int item)

    {

        data = item;

        left = right = null;

    }

}

  

class GFG

{

public Node root;

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

public virtual void printSpecificLevelOrder(Node node)

{

    if (node == null)

    {

        return;

    }

  

    // Сначала распечатаем корень и следующий уровень

    Console.Write(node.data);

  

    // Так как это идеальное двоичное дерево,

    // право не проверено

    if (node.left != null)

    {

        Console.Write(" " + node.left.data +

                      " " + node.right.data);

    }

  

    // Делай что-нибудь еще, если есть

    // узлы на следующем уровне в

    // дано идеальное бинарное дерево

    if (node.left.left == null)

    {

        return;

    }

  

    // Создать очередь и поставить в очередь слева

    // и правые потомки корня

    LinkedList<Node> q = new LinkedList<Node>();

    q.AddLast(node.left);

    q.AddLast(node.right);

  

    // Мы обрабатываем два узла одновременно,

    // поэтому нам нужны две переменные

    // сохраняем два передних элемента очереди

    Node first = null, second = null;

  

    // цикл обхода

    while (q.Count > 0)

    {

        // извлекаем два элемента из очереди

        first = q.First.Value;

        q.RemoveFirst();

        second = q.First.Value;

        q.RemoveFirst();

  

        // Печать детей первого и

        // второй в обратном порядке

        Console.Write(" " + first.left.data + 

                      " " + second.right.data);

        Console.Write(" " + first.right.data + 

                      " " + second.left.data);

  

        // Если у первого и второго есть внуки,

        // ставим их в очередь в обратном порядке

        if (first.left.left != null)

        {

            q.AddLast(first.left);

            q.AddLast(second.right);

            q.AddLast(first.right);

            q.AddLast(second.left);

        }

    }

}

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

public static void Main(string[] args)

{

    GFG tree = new GFG();

    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.left = new Node(6);

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

  

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

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

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

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

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

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

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

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

  

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  

    Console.WriteLine("Specific Level Order " + 

                      "traversal of binary" + "tree is ");

    tree.printSpecificLevelOrder(tree.root);

}
}

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

Выход:

Specific Level Order traversal of binary tree is
1 2 3 4 7 5 6 8 15 9 14 10 13 11 12 16 31 17 30 18 29 19 28 20 27 21 26 22 25 23 24

Последующие вопросы:

  1. Приведенный выше код печатает определенный порядок уровней от TOP до BOTTOM. Как вы будете выполнять определенный обход уровня от ДНА до ТОП ( Amazon Interview | Set 120 — Last Round Last Problem )
  2. Что делать, если дерево не идеально, но завершено.
  3. Что, если дерево не является ни совершенным, ни полным. Это может быть любое общее двоичное дерево.

Эта статья предоставлена Анураг Сингх . Пожалуйста, пишите комментарии, если вы обнаружите что-то неправильное или вы хотите поделиться дополнительной информацией по обсуждаемой выше теме.

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

Идеальный двоичный древовидный порядок обхода порядка

0.00 (0%) 0 votes