Travessament de l'ordre de nivell La tècnica es defineix com un mètode per travessar un arbre de manera que tots els nodes presents al mateix nivell es travessin completament abans de travessar el següent nivell.
Exemple:
Recorregut per ordre de nivell de pràctica recomanat Prova-ho!Entrada:
Sortida:
1
2 3
4 5
Com funciona el Level Order Traversal?
La idea principal del recorregut per ordre de nivell és travessar tots els nodes d'un nivell inferior abans de passar a qualsevol dels nodes d'un nivell superior. Això es pot fer de qualsevol de les maneres següents:
- l'ingenu (trobar l'alçada de l'arbre i recórrer cada nivell i imprimir els nodes d'aquest nivell)
- utilitzant de manera eficient una cua.
Travessament de l'ordre de nivell (enfocament ingenu):
Troba alçada d'arbre. A continuació, per a cada nivell, executeu una funció recursiva mantenint l'alçada actual. Sempre que el nivell d'un node coincideixi, imprimiu aquest node.
A continuació es mostra la implementació de l'enfocament anterior:
C++ // Recursive CPP program for level // order traversal of Binary Tree #include using namespace std; // A binary tree node has data, // pointer to left child // and a pointer to right child class node { public: int data; node *left, *right; }; // Function prototypes void printCurrentLevel(node* root, int level); int height(node* node); node* newNode(int data); // Function to print level order traversal a tree void printLevelOrder(node* root) { int h = height(root); int i; for (i = 1; i <= h; i++) printCurrentLevel(root, i); } // Print nodes at a current level void printCurrentLevel(node* root, int level) { if (root == NULL) return; if (level == 1) cout << root->dades<< ' '; else if (level>1) { printCurrentLevel(arrel->esquerra, nivell - 1); printCurrentLevel(arrel->dreta, nivell - 1); } } // Calcula l''alçada' d'un arbre -- el nombre de // nodes al llarg del camí més llarg des del node arrel // fins al node full més llunyà. int alçada(node* node) { if (node == NULL) retorna 0; else { // Calcula l'alçada de cada subarbre int lheight = height(node->left); int alçada = alçada (node->dreta); // Utilitzeu el més gran if (lheight> rheight) { return (lheight + 1); } else { retorn (altura dreta + 1); } } } // Funció auxiliar que assigna // un nou node amb les dades donades i // punters esquerre i dret NULL. node* nouNode(dades int) { node* Node = nou node(); Node->dades = dades; Node->esquerra = NULL; Node->dreta = NULL; retorn (Node); } // Codi del controlador int main() { node* arrel = nouNode(1); arrel->esquerra = nouNode(2); arrel->dreta = nouNode(3); arrel->esquerra->esquerra = nouNode(4); arrel->esquerra->dreta = nouNode(5); cout<< 'Level Order traversal of binary tree is
'; printLevelOrder(root); return 0; } // This code is contributed by rathbhupendra> C // Recursive C program for level // order traversal of Binary Tree #include #include // A binary tree node has data, // pointer to left child // and a pointer to right child struct node { int data; struct node *left, *right; }; // Function prototypes void printCurrentLevel(struct node* root, int level); int height(struct node* node); struct node* newNode(int data); // Function to print level order traversal a tree void printLevelOrder(struct node* root) { int h = height(root); int i; for (i = 1; i <= h; i++) printCurrentLevel(root, i); } // Print nodes at a current level void printCurrentLevel(struct node* root, int level) { if (root == NULL) return; if (level == 1) printf('%d ', root->dades); else if (nivell> 1) { printCurrentLevel (arrel->esquerra, nivell - 1); printCurrentLevel(arrel->dreta, nivell - 1); } } // Calcula l''alçada' d'un arbre -- el nombre de // nodes al llarg del camí més llarg des del node arrel // fins al node full més allunyat int height(struct node* node) { if (node == NULL) retorna 0; else { // Calcula l'alçada de cada subarbre int lheight = height(node->left); int alçada = alçada (node->dreta); // Utilitzeu el més gran si (altura> dreta) retorna (altura + 1); sinó tornar (dreta + 1); } } // Funció d'ajuda que assigna un nou node amb les // dades donades i punters NULL esquerre i dret. struct node* newNode(int data) { struct node* node = (struct node*)malloc(sizeof(struct node)); node->dades = dades; node->esquerra = NULL; node->dreta = NULL; retorn (node); } // Programa controlador per provar les funcions anteriors int main() { struct node* root = newNode(1); arrel->esquerra = nouNode(2); arrel->dreta = nouNode(3); arrel->esquerra->esquerra = nouNode(4); arrel->esquerra->dreta = nouNode(5); printf('El recorregut de l'ordre de nivell de l'arbre binari és
'); printLevelOrder (arrel); retorn 0; }>>>Javarheight) retorn (lheight + 1); sinó tornar (dreta + 1); } } // Imprimeix nodes al nivell actual void printCurrentLevel(Arrel del node, nivell int) { if (arrel == null) retorn; if (nivell == 1) System.out.print(root.data + ' '); else if (nivell> 1) { printCurrentLevel (arrel.esquerra, nivell - 1); printCurrentLevel(arrel.dreta, nivell - 1); } } // Programa controlador per provar les funcions anteriors public static void main(String args[]) { BinaryTree tree = new BinaryTree(); tree.root = nou Node (1); tree.root.left = nou Node (2); tree.root.right = nou Node (3); tree.root.left.left = nou Node (4); tree.root.left.right = nou Node (5); System.out.println('El recorregut de l'ordre de nivell de' + 'l'arbre binari és '); tree.printLevelOrder(); } }>>> Python1: printCurrentLevel(root.left, level-1) printCurrentLevel(root.right, level-1) # Calcula l'alçada d'un arbre: el nombre de nodes # al llarg del camí més llarg des del node arrel fins a # la fulla més llunyana node def height(node): si el node és Cap: retorna 0 else: # Calculeu l'alçada de cada subarbre lheight = height(node.left) rheight = height(node.right) # Utilitzeu el més gran si lheight> rheight: retorn lheight+1 else: retorna rheight+1 # Programa de controlador per provar la funció anterior si __name__ == '__main__': root = Node(1) root.left = Node (2) root.right = Node (3) arrel. left.left = Node (4) root.left.right = Node (5) print('El recorregut de l'ordre de nivell de l'arbre binari és -') printLevelOrder (arrel) # Aquest codi és aportat per Nikhil Kumar Singh (nickzuck_007)> C# // Recursive c# program for level // order traversal of Binary Tree using System; // Class containing left and right // child of current node and key value public class Node { public int data; public Node left, right; public Node(int item) { data = item; left = right = null; } } class GFG { // Root of the Binary Tree public Node root; public void BinaryTree() { root = null; } // Function to print level order // traversal of tree public virtual void printLevelOrder() { int h = height(root); int i; for (i = 1; i <= h; i++) { printCurrentLevel(root, i); } } // Compute the 'height' of a tree -- // the number of nodes along the longest // path from the root node down to the // farthest leaf node. public virtual int height(Node root) { if (root == null) { return 0; } else { // Compute height of each subtree int lheight = height(root.left); int rheight = height(root.right); // use the larger one if (lheight>rheight) { retorn (lheight + 1); } else { retorn (altura dreta + 1); } } } // Imprimeix nodes al nivell actual public virtual void printCurrentLevel(Arrel del node, nivell int) { if (arrel == null) { retorn; } if (nivell == 1) { Console.Write(root.data + ' '); } else if (nivell> 1) { printCurrentLevel (arrel.esquerra, nivell - 1); printCurrentLevel(arrel.dreta, nivell - 1); } } // Codi del controlador public static void Main(string[] args) { GFG tree = new GFG(); tree.root = nou Node (1); tree.root.left = nou Node (2); tree.root.right = nou Node (3); tree.root.left.left = nou Node (4); tree.root.left.right = nou Node (5); Console.WriteLine('El recorregut de l'ordre de nivell ' + 'de l'arbre binari és '); tree.printLevelOrder(); } } // Aquest codi és aportat per Shrikant13>>Javascriptrheight) retorn (lheight + 1); sinó tornar (dreta + 1); } } // Imprimeix nodes al nivell actual funció printCurrentLevel(arrel, nivell) { if (arrel == null) retorn; if (nivell == 1) console.log(root.data + ' '); else if (nivell> 1) { printCurrentLevel (arrel.esquerra, nivell - 1); printCurrentLevel(arrel.dreta, nivell - 1); } } // Programa controlador per provar les funcions anteriors root = nou Node(1); root.left = nou Node (2); root.right = nou Node (3); root.left.left = nou Node (4); root.left.right = nou Node (5); console.log('El recorregut de l'ordre de nivell de l'arbre binari és '); printLevelOrder(); // Aquest codi és aportat per umadevi9616>>>
Sortida Level Order traversal of binary tree is 1 2 3 4 5>
Complexitat temporal: O(N), on N és el nombre de nodes de l'arbre esbiaixat.
Espai auxiliar: O(1) Si es considera la pila de recursivitat, l'espai utilitzat és O(N).
diferència entre guineu i llop
Travessament de l'ordre de nivell utilitzant Cua
Hem de visitar els nodes d'un nivell inferior abans que qualsevol node d'un nivell superior, aquesta idea és força semblant a la d'una cua. Empènyer els nodes d'un nivell inferior a la cua. Quan es visiti qualsevol node, extreu aquest node de la cua i empenyeu el fill d'aquest node a la cua.
Això garanteix que el node d'un nivell inferior sigui visitat abans de qualsevol node d'un nivell superior.
A continuació es mostra la implementació de l'enfocament anterior:
C++ // C++ program to print level order traversal #include using namespace std; // A Binary Tree Node struct Node { int data; struct Node *left, *right; }; // Iterative method to find height of Binary Tree void printLevelOrder(Node* root) { // Base Case if (root == NULL) return; // Create an empty queue for level order traversal queueq; // Col·loqueu l'arrel a la cua i inicialitzeu l'alçada q.push(arrel); while (q.empty() == false) { // Imprimeix la part davantera de la cua i elimina-la de la cua Node* node = q.front(); cout<< node->dades<< ' '; q.pop(); // Enqueue left child if (node->esquerra != NULL) q.push(node->esquerra); // Posa a la cua el fill dret si (node->right != NULL) q.push(node->right); } } // Funció d'utilitat per crear un nou node d'arbre Node* newNode(int data) { Node* temp = nou Node; temp->data = dades; temp->esquerra = temp->dreta = NULL; temperatura de retorn; } // Programa controlador per provar les funcions anteriors int main() { // Creem l'arbre binari que es mostra al diagrama anterior Node* root = newNode(1); arrel->esquerra = nouNode(2); arrel->dreta = nouNode(3); arrel->esquerra->esquerra = nouNode(4); arrel->esquerra->dreta = nouNode(5); cout<< 'Level Order traversal of binary tree is
'; printLevelOrder(root); return 0; }> C // Iterative Queue based C program // to do level order traversal // of Binary Tree #include #include #define MAX_Q_SIZE 500 // A binary tree node has data, // pointer to left child // and a pointer to right child struct node { int data; struct node* left; struct node* right; }; // Function prototypes struct node** createQueue(int*, int*); void enQueue(struct node**, int*, struct node*); struct node* deQueue(struct node**, int*); // Given a binary tree, print its nodes in level order // using array for implementing queue void printLevelOrder(struct node* root) { int rear, front; struct node** queue = createQueue(&front, &rear); struct node* temp_node = root; while (temp_node) { printf('%d ', temp_node->dades); // Posa a la cua el fill esquerre si (temp_node->esquerra) enQueue(queue, &rear, temp_node->left); // Posa a la cua fill dret if (temp_node->right) enQueue(queue, &rear, temp_node->right); // Treu el node de cua i fes-lo temp_node temp_node = deQueue(queue, &front); } } // Funcions d'utilitat struct node** createQueue(int* front, int* rear) { struct node** queue = (struct node**)malloc( sizeof (struct node*) * MAX_Q_SIZE); *davant = *darrera = 0; cua de retorn; } void enQueue(struct node** cua, int* posterior, struct node* new_node) { queue[*rear] = new_node; (*darrera)++; } struct node* deQueue(struct node** cua, int* front) { (*front)++; retorna la cua[*front - 1]; } // Funció auxiliar que assigna un nou node amb les // dades donades i punters NULL esquerre i dret. struct node* newNode(int data) { struct node* node = (struct node*)malloc(sizeof(struct node)); node->dades = dades; node->esquerra = NULL; node->dreta = NULL; retorn (node); } // Programa controlador per provar les funcions anteriors int main() { struct node* root = newNode(1); arrel->esquerra = nouNode(2); arrel->dreta = nouNode(3); arrel->esquerra->esquerra = nouNode(4); arrel->esquerra->dreta = nouNode(5); printf('El recorregut de l'ordre de nivell de l'arbre binari és
'); printLevelOrder (arrel); retorn 0; }>>>Java>> Python C# // Iterative Queue based C# program // to do level order traversal // of Binary Tree using System; using System.Collections.Generic; // Class to represent Tree node public class Node { public int data; public Node left, right; public Node(int item) { data = item; left = null; right = null; } } // Class to print Level Order Traversal public class BinaryTree { Node root; // Given a binary tree. Print // its nodes in level order using // array for implementing queue void printLevelOrder() { Queuequeue = cua nova(); queue.Enqueue(arrel); while (queue.Count!= 0) { Node tempNode = queue.Dequeue(); Console.Write(tempNode.data + ' '); // Posa a la cua el fill esquerre si (tempNode.left != null) { queue.Enqueue (tempNode.left); } // Posa a la cua fill dret si (tempNode.right != null) { queue.Enqueue (tempNode.right); } } } // Codi del controlador public static void Main() { // Creant un arbre binari i introduint // els nodes BinaryTree tree_level = new BinaryTree(); tree_level.root = nou Node (1); tree_level.root.left = nou Node (2); tree_level.root.right = nou Node (3); tree_level.root.left.left = nou Node (4); tree_level.root.left.right = nou Node (5); Console.WriteLine('El recorregut de l'ordre de nivell ' + 'de l'arbre binari és - '); nivell_arbre.printLevelOrder(); } } // Aquest codi aportat per PrinciRaj1992>>>Javascript Sortida
Espai auxiliar: O(N) on N és el nombre de nodes de l'arbre binari.