Рубрики

Perfect Бинарное дерево Специфичный уровень Порядок обхода | Набор 2

Совершенное бинарное дерево с использованием обхода порядка определенного уровня в наборе 1 . Предыдущий обход был сверху вниз. В этом посте обсуждается обход снизу вверх (задается в интервью Amazon | Set 120 — Round 1 ).

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

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

5th level: 16(left), 31(right), 17(left), 30(right), … are printed.

4th level: 8(left), 15(right), 9(left), 14(right), … are printed.

3rd level: 4(left), 7(right), 5(left), 6(right) are printed.

1st and 2nd levels are trivial. 

Подход 1
Идея стандартного обхода порядка здесь немного меняется.

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

C ++

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

using namespace std;

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

struct Node

{

    int data;

    Node *left, *right;

};

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

Node* newNode(int data)

{

    Node* node = new Node;

    node->data = data;

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

    return node;

}

  

void printSpecificLevelOrderUtil(Node* root, stack<Node*> &s)

{

    if (root == NULL)

        return;

  

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

    // дети корня

    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();

  

        // Push первого и второго узла детей

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

        s.push(second->left);

        s.push(first->right);

        s.push(second->right);

        s.push(first->left);

  

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

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

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

        {

            q.push(first->right);

            q.push(second->left);

            q.push(first->left);

            q.push(second->right);

        }

    }

}

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

void printSpecificLevelOrder(Node* root)

{

    // создаем стек и выдвигаем root

    stack<Node*> s;

  

    // Вставляем узлы уровня 1 и уровня 2 в стек

    s.push(root);

  

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

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

    if (root->left != NULL)

    {

        s.push(root->right);

        s.push(root->left);

    }

  

    // Делаем что-нибудь еще, если рядом есть узлы

    // уровень в заданном совершенном бинарном дереве

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

        printSpecificLevelOrderUtil(root, s);

  

    // Наконец извлекаем все узлы из стека и распечатываем

    // их

    while (!s.empty())

    {

        cout << s.top()->data << " ";

        s.pop();

    }

}

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

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.*;

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

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

class Node 

{

    int data;

    Node left, right;

  

    public Node(int data) 

    {

        this.data = data;

        left = right = null;

    }

}

  

class BinaryTree 

{

    Node root;

  

    void printSpecificLevelOrderUtil(Node root, Stack<Node> s) 

    {

        if (root == null)

            return;

  

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

        // дети корня

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

  

        q.add(root.left);

        q.add(root.right);

  

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

        // нужны две переменные для хранения двух фронтальных

        // элементы очереди

        Node first = null, second = null;

  

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

        while (!q.isEmpty()) 

        {

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

            first = q.peek();

            q.poll();

            second = q.peek();

            q.poll();

  

            // Push первого и второго узла детей

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

            s.push(second.left);

            s.push(first.right);

            s.push(second.right);

            s.push(first.left);

  

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

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

            if (first.left.left != null

            {

                q.add(first.right);

                q.add(second.left);

                q.add(first.left);

                q.add(second.right);

            }

        }

    }

  

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

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

    void printSpecificLevelOrder(Node root) 

    {

        // создаем стек и выдвигаем root

        Stack<Node> s = new Stack<Node>();

  

        // Вставляем узлы уровня 1 и уровня 2 в стек

        s.push(root);

  

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

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

        if (root.left != null

        {

            s.push(root.right);

            s.push(root.left);

        }

  

        // Делаем что-нибудь еще, если рядом есть узлы

        // уровень в заданном совершенном бинарном дереве

        if (root.left.left != null)

            printSpecificLevelOrderUtil(root, s);

  

        // Наконец извлекаем все узлы из стека и распечатываем

        // их

        while (!s.empty()) 

        {

            System.out.print(s.peek().data + " ");

            s.pop();

        }

    }

  

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

    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 = новый узел (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 = новый узел (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 = новый узел (16);

        tree.root.left.left.left.right = новый узел (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 = новый узел (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 = новый узел (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 (mayank_24)

python3

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

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

class Node:

      

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

    # и правый потомок корня

    s = []

    q = []

      

    # Переменная для прохождения обращенного массива

    elements = 0

      

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

    def __init__(self, key):

        self.data = key

        self.left = None

        self.right = None

  

    # При условии идеальной печати двоичного дерева

    # его узел в определенном порядке

    def printSpecificLevelOrder(self, root):

        self.s.append(root)

          

        # Pop элемент из списка

        prnt = self.s.pop(0)

        self.q.append(prnt.data)

        if prnt.right:

            self.s.append(root.right)

        if prnt.left:

            self.s.append(root.left)

              

        # Цикл обхода

        while(len(self.s) > 0):

              

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

            first = self.s.pop(0)

            self.q.append(first.data)

            second = self.s.pop(0)

            self.q.append(second.data)

              

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

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

            if first.left and second.right and first.right and second.left:

                  

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

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

                self.s.append(first.left)

                self.s.append(second.right)

                self.s.append(first.right)

                self.s.append(second.left)

  

        # Дайте идеальный отпечаток бинарного дерева

        # его узел в обратном порядке

        for elements in reversed(self.q):

            print(elements, end=" ")

  

  
Код водителя

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")

root.printSpecificLevelOrder(root)

  

  
# Этот код предоставлен 'Vaibhav Kumar 12'

C #

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

using System;

using System.Collections.Generic;

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

public class Node

{

    public int data;

    public Node left, right;

  

    public Node(int data)

    {

        this.data = data;

        left = right = null;

    }

}

  

class GFG

{

public Node root;

  

public virtual void printSpecificLevelOrderUtil(Node root, 

                                                Stack<Node> s)

{

    if (root == null)

    {

        return;

    }

  

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

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

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

  

    q.AddLast(root.left);

    q.AddLast(root.right);

  

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

    // нужны две переменные для хранения двух фронтальных

    // элементы очереди

    Node first = null, second = null;

  

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

    while (q.Count > 0)

    {

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

        first = q.First.Value;

        q.RemoveFirst();

        second = q.First.Value;

        q.RemoveFirst();

  

        // Push первого и второго узла

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

        s.Push(second.left);

        s.Push(first.right);

        s.Push(second.right);

        s.Push(first.left);

  

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

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

        if (first.left.left != null)

        {

            q.AddLast(first.right);

            q.AddLast(second.left);

            q.AddLast(first.left);

            q.AddLast(second.right);

        }

    }

}

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

public virtual void printSpecificLevelOrder(Node root)

{

    // создаем стек и выдвигаем root

    Stack<Node> s = new Stack<Node>();

  

    // Нажмите уровень 1 и уровень 2

    // узлы в стеке

    s.Push(root);

  

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

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

    if (root.left != null)

    {

        s.Push(root.right);

        s.Push(root.left);

    }

  

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

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

    // совершенное двоичное дерево

    if (root.left.left != null)

    {

        printSpecificLevelOrderUtil(root, s);

    }

  

    // Наконец, вытолкнуть все узлы из

    // укладываем и печатаем их.

    while (s.Count > 0)

    {

        Console.Write(s.Peek().data + " ");

        s.Pop();

    }

}

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

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 = новый узел (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 = новый узел (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 = новый узел (16);

    tree.root.left.left.left.right = новый узел (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 = новый узел (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 = новый узел (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 
2 3 1 

Подход 2: (с использованием вектора)

  1. Мы пройдем каждый уровень сверху вниз и будем толкать каждый уровень, чтобы складывать сверху вниз
  2. так что мы можем, наконец, до печатных уровней,
  3. у нас есть уровень в векторе, поэтому мы можем напечатать его любым определенным способом,

C ++

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

using namespace std;

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

class Node

{

    public:

        int data;

        Node* left;

        Node* right;

          

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

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

        Node(int value)

        {

            data = value;

            left = NULL;

            right = NULL;

        }

};

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

void specific_level_order_traversal(Node* root)

{

    // для обхода порядка уровня

    queue <Node*> q;

    // стек для обратной печати

    stack < vector <int> > s; 

      

    q.push(root);

    int sz;

      

    while(!q.empty())

    {

        vector <int> v;    // вектор для хранения уровня

        sz = q.size();    // учитывая размер уровня

          

        for(int i=0;i<sz;++i)

        {

            Node* temp = q.front();

            q.pop();

              

            // помещаем данные узла определенного уровня в вектор

            v.push_back(temp->data); 

              

            if(temp->left!=NULL)

            q.push(temp->left);

      

            if(temp->right!=NULL)

                q.push(temp->right);

        }

          

        // толкаем вектор, связывающийся с уровнем в стеке

        s.push(v); 

    }

      

    // печатаем стопку

    while(!s.empty())

    {

        // Наконец извлекаем все узлы из стека и распечатываем

        // их

        vector <int> v = s.top();

        s.pop();

        for(int i=0,j=v.size()-1;i<j;++i)

            {

                cout<<v[i]<<" "<<v[j]<<" ";

                j--;

            }

    }

      

    // наконец печатаем root;

    cout<<root->data;

      
}

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

int main()

{

    Node *root = new Node(1);

  

    root->left = new Node(2);

    root->right = new Node(3);

  
/ * root-> left-> left = new Node (4);

    root-> left-> right = new Node (5);

    root-> right-> left = new Node (6);

    root-> right-> right = new Node (7);

  

    root-> left-> left-> left = new Node (8);

    root-> left-> left-> right = new Node (9);

    root-> left-> right-> left = new Node (10);

    root-> left-> right-> right = new Node (11);

    root-> right-> left-> left = new Node (12);

    root-> right-> left-> right = new Node (13);

    root-> right-> right-> left = new Node (14);

    root-> right-> right-> right = new Node (15);

  

    root-> left-> left-> left-> left = new Node (16);

    root-> left-> left-> left-> right = new Node (17);

    root-> left-> left-> right-> left = new Node (18);

    root-> left-> left-> right-> right = new Node (19);

    root-> left-> right-> left-> left = new Node (20);

    root-> left-> right-> left-> right = new Node (21);

    root-> left-> right-> right-> left = new Node (22);

    root-> left-> right-> right-> right = new Node (23);

    root-> right-> left-> left-> left = new Node (24);

    root-> right-> left-> left-> right = new Node (25);

    root-> right-> left-> right-> left = new Node (26);

    root-> right-> left-> right-> right = new Node (27);

    root-> right-> right-> left-> left = new Node (28);

    root-> right-> right-> left-> right = new Node (29);

    root-> right-> right-> right-> left = new Node (30);

    root-> right-> right-> right-> right = new Node (31); * /

    cout << "Specific Level Order traversal of binary "

        "tree is \n";

    specific_level_order_traversal(root);

    return 0;

}
// Этот код предоставлен Rachit Yadav.

Джава

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

import java.util.*;

  

class GFG

{

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

static class Node 

    int data; 

    Node left; 

    Node right; 

      

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

    новый узел с заданными данными и

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

    Node(int value) 

    

        data = value; 

        left = null

        right = null

    

}; 

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

static void specific_level_order_traversal(Node root) 

    // для обхода порядка уровня

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

      

    // Стек для печати в обратном порядке

    Stack <Vector<Integer>> s = new Stack<Vector<Integer>>();

      

    q.add(root); 

    int sz; 

      

    while(q.size() > 0

    

        // вектор для хранения уровня

        Vector<Integer> v = new Vector<Integer>(); 

        sz = q.size(); // учитывая размер уровня

          

        for(int i = 0; i < sz; ++i) 

        

            Node temp = q.peek(); 

            q.remove(); 

              

            // выдвигаем данные узла

            // определенный уровень к вектору

            v.add(temp.data); 

              

            if(temp.left != null

            q.add(temp.left); 

      

            if(temp.right != null

                q.add(temp.right); 

        

          

        // толкаем вектор, связывающийся с уровнем в стеке

        s.push(v); 

    

      

    // печатаем стек

    while(s.size() > 0

    

        // Наконец, вытолкнуть все узлы из стека

        // и печатает их.

        Vector <Integer> v = s.peek(); 

        s.pop(); 

        for(int i = 0, j = v.size() - 1; i < j; ++i) 

            

                System.out.print(v.get(i) + " "

                                 v.get(j) + " "); 

                j--; 

            

    

      

    // наконец печатаем root;

    System.out.println(root.data); 

      

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

public static void main(String args[])

    Node root = new Node(1); 

  

    root.left = new Node(2); 

    root.right = new Node(3); 

  

 / * root.left.left = new Node (4);

    root.left.right = новый узел (5);

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

    root.right.right = новый узел (7);

  

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

    root.left.left.right = новый узел (9);

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

    root.left.right.right = новый узел (11);

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

    root.right.left.right = новый узел (13);

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

    root.right.right.right = новый узел (15);

  

    root.left.left.left.left = новый узел (16);

    root.left.left.left.right = новый узел (17);

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

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

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

    root.left.right.left.right = новый узел (21);

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

    root.left.right.right.right = новый узел (23);

    root.right.left.left.left = новый узел (24);

    root.right.left.left.right = новый узел (25);

    root.right.left.right.left = новый узел (26);

    root.right.left.right.right = новый узел (27);

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

    root.right.right.left.right = новый узел (29);

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

    root.right.right.right.right = новый узел (31); * /

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

                                   " of binary tree is"); 

    specific_level_order_traversal(root); 

}
}

  
// Этот код предоставлен Арнабом Кунду

C #

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

using System;

using System.Collections.Generic;

      

class GFG

{

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

public class Node 

    public int data; 

    public Node left; 

    public Node right; 

      

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

    новый узел с заданными данными и

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

    public Node(int value) 

    

        data = value; 

        left = null

        right = null

    

}; 

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

static void specific_level_order_traversal(Node root) 

    // для обхода порядка уровня

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

      

    // Стек для печати в обратном порядке

    Stack <List<int>> s = new Stack<List<int>>();

      

    q.Enqueue(root); 

    int sz; 

      

    while(q.Count > 0) 

    

        // вектор для хранения уровня

        List<int> v = new List<int>(); 

          

        // учитывая размер уровня

        sz = q.Count; 

          

        for(int i = 0; i < sz; ++i) 

        

            Node temp = q.Peek(); 

            q.Dequeue(); 

              

            // выдвигаем данные узла

            // определенный уровень к вектору

            v.Add(temp.data); 

              

            if(temp.left != null

            q.Enqueue(temp.left); 

      

            if(temp.right != null

                q.Enqueue(temp.right); 

        

          

        // толкаем вектор, связывающийся с уровнем в стеке

        s.Push(v); 

    

      

    // печатаем стек

    while(s.Count > 0) 

    

        // Наконец, вытолкнуть все узлы из стека

        // и печатает их.

        List<int> v = s.Peek(); 

        s.Pop(); 

        for(int i = 0, 

                j = v.Count - 1; i < j; ++i) 

        

            Console.Write(v[i] + " "

                          v[j] + " "); 

            j--; 

        

    

      

    // наконец печатаем root;

    Console.WriteLine(root.data); 

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

public static void Main(String []args)

    Node root = new Node(1); 

  

    root.left = new Node(2); 

    root.right = new Node(3); 

  

 / * root.left.left = new Node (4);

    root.left.right = новый узел (5);

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

    root.right.right = новый узел (7);

  

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

    root.left.left.right = новый узел (9);

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

    root.left.right.right = новый узел (11);

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

    root.right.left.right = новый узел (13);

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

    root.right.right.right = новый узел (15);

  

    root.left.left.left.left = новый узел (16);

    root.left.left.left.right = новый узел (17);

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

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

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

    root.left.right.left.right = новый узел (21);

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

    root.left.right.right.right = новый узел (23);

    root.right.left.left.left = новый узел (24);

    root.right.left.left.right = новый узел (25);

    root.right.left.right.left = новый узел (26);

    root.right.left.right.right = новый узел (27);

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

    root.right.right.left.right = новый узел (29);

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

    root.right.right.right.right = новый узел (31); * /

    Console.WriteLine("Specific Level Order traversal"

                                  " of binary tree is"); 

    specific_level_order_traversal(root); 

}
}

  
// Этот код предоставлен Rajput-Ji


Выход :

Specific Level Order traversal of binary tree is 
2 3 1 

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

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

Perfect Бинарное дерево Специфичный уровень Порядок обхода | Набор 2

0.00 (0%) 0 votes