TRAVERSÉE POST-COMMANDE DE L'ARBRE BINAIRE

Traversée des mandats postaux est défini comme un type de parcours d'arbre qui suit la politique Left-Right-Root telle que pour chaque nœud :

Le sous-arbre de gauche est parcouru en premier

Ensuite, le sous-arbre droit est parcouru

Enfin, le nœud racine du sous-arbre est parcouru

Traversée des mandats postaux

Algorithme pour la traversée post-ordre de l'arbre binaire :

L'algorithme de parcours post-ordre est présenté comme suit :

Mandat postal (racine) :

Suivez les étapes 2 à 4 jusqu'à ce que root != NULL

Postcommande (racine -> gauche)

Postcommande (racine -> droite)

Écrire racine -> données

Fin de la boucle

Comment fonctionne la traversée post-commande de l'arbre binaire ?

Considérons l'arbre suivant :

Exemple d'arbre binaire

Si nous effectuons un parcours post-ordre dans cet arbre binaire, alors le parcours sera le suivant :

Étape 1: Le parcours ira de 1 à son sous-arbre gauche, c'est-à-dire 2, puis de 2 à la racine de son sous-arbre gauche, c'est-à-dire 4. Maintenant, 4 n'a plus de sous-arbre, il sera donc visité.

Le nœud 4 est visité

Étape 2: Comme le sous-arbre gauche de 2 est visité complètement, il traversera maintenant le sous-arbre droit de 2, c'est-à-dire qu'il se déplacera vers 5. Comme il n'y a pas de sous-arbre de 5, il sera visité.

Le nœud 5 est visité

Étape 3: Maintenant, les sous-arbres gauche et droit du nœud 2 sont visités. Alors maintenant, visitez le nœud 2 lui-même.

Le nœud 2 est visité

Étape 4: Au fur et à mesure que le sous-arbre gauche du nœud 1 est traversé, il se déplacera maintenant vers la racine du sous-arbre droit, c'est-à-dire 3. Le nœud 3 n'a pas de sous-arbre gauche, il traversera donc le sous-arbre droit, c'est-à-dire 6. Le nœud 6 n'a pas de sous-arbre et donc on le visite.

Le nœud 6 est visité

Étape 5 : Tous les sous-arbres du nœud 3 sont parcourus. Alors maintenant, le nœud 3 est visité.

Le nœud 3 est visité

Étape 6 : Comme tous les sous-arbres du nœud 1 sont parcourus, il est maintenant temps de visiter le nœud 1 et le parcours se termine après cela lorsque l'arbre entier est parcouru.

L'arbre complet est visité

L’ordre de parcours des nœuds est donc 4 -> 5 -> 2 -> 6 -> 3 -> 1 .

Programme pour implémenter la traversée post-ordre de l'arbre binaire

Vous trouverez ci-dessous l'implémentation du code du parcours post-commande :

C++

// C++ program for postorder traversals> #include> using> namespace> std;> // Structure of a Binary Tree Node> struct> Node {> > int> data;> > struct> Node *left, *right;> > Node(> int> v)> > {> > data = v;> > left = right = NULL;> > }> };> // Function to print postorder traversal> void> printPostorder(> struct> Node* node)> {> > if> (node == NULL)> > return> ;> > // First recur on left subtree> > printPostorder(node->à gauche);> > // Then recur on right subtree> > printPostorder(node->à droite);> > // Now deal with the node> >

cout ' '; } // Driver code int main() {  struct Node* root = new Node(1);  root->gauche = nouveau nœud (2);  racine->droite = new Node(3);  racine->gauche->gauche = new Node(4);  racine->gauche->droite = new Node(5);  racine->droite->droite = new Node(6);  // Appel de fonction cout < < 'Postorder traversal of binary tree is: 
';  printPostorder(root);  return 0; }>

Java

// Java program for postorder traversals> import> java.util.*;> // Structure of a Binary Tree Node> class> Node {> > int> data;> > Node left, right;> > Node(> int> v)> > {> > data = v;> > left = right => null> ;> > }> }> class> GFG {> > > // Function to print postorder traversal> > static> void> printPostorder(Node node)> > {> > if> (node ==> null> )> > return> ;> > // First recur on left subtree> > printPostorder(node.left);> > // Then recur on right subtree> > printPostorder(node.right);> > // Now deal with the node> > System.out.print(node.data +> ' '> );> > }> > // Driver code> > 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 => new> Node(> 5> );> > root.right.right => new> Node(> 6> );> > // Function call> > System.out.println(> 'Postorder traversal of binary tree is: '> );> > printPostorder(root);> > }> }> // This code is contributed by prasad264>

Python3

# Python program for postorder traversals> # Structure of a Binary Tree Node> class> Node:> > def> __init__(> self> , v):> > self> .data> => v> > self> .left> => None> > self> .right> => None> # Function to print postorder traversal> def> printPostorder(node):> > if> node> => => None> :> > return> > # First recur on left subtree> > printPostorder(node.left)> > # Then recur on right subtree> > printPostorder(node.right)> > # Now deal with the node> > print> (node.data, end> => ' '> )> # Driver code> if> __name__> => => '__main__'> :> > root> => Node(> 1> )> > root.left> => Node(> 2> )> > root.right> => Node(> 3> )> > root.left.left> => Node(> 4> )> > root.left.right> => Node(> 5> )> > root.right.right> => Node(> 6> )> > # Function call> > print> (> 'Postorder traversal of binary tree is:'> )> > printPostorder(root)>

C#

// C# program for postorder traversals> using> System;> // Structure of a Binary Tree Node> public> class> Node {> > public> int> data;> > public> Node left, right;> > public> Node(> int> v)> > {> > data = v;> > left = right => null> ;> > }> }> public> class> GFG {> > // Function to print postorder traversal> > static> void> printPostorder(Node node)> > {> > if> (node ==> null> )> > return> ;> > // First recur on left subtree> > printPostorder(node.left);> > // Then recur on right subtree> > printPostorder(node.right);> > // Now deal with the node> > Console.Write(node.data +> ' '> );> > }> > static> public> void> Main()> > {> > // Code> > 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.right => new> Node(6);> > // Function call> > Console.WriteLine(> > 'Postorder traversal of binary tree is: '> );> > printPostorder(root);> > }> }> // This code is contributed by karthik.>

Javascript

// Structure of a Binary Tree Node> class Node {> > constructor(v) {> > this> .data = v;> > this> .left => null> ;> > this> .right => null> ;> > }> }> // Function to print postorder traversal> function> printPostorder(node) {> > if> (node ==> null> ) {> > return> ;> > }> > // First recur on left subtree> > printPostorder(node.left);> > // Then recur on right subtree> > printPostorder(node.right);> > // Now deal with the node> > console.log(node.data +> ' '> );> }> // Driver code> function> main() {> > let 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.right => new> Node(6);> > // Function call> > console.log(>

'Postorder traversal of binary tree is: 
'>

);> > printPostorder(root);> }> main();>

Sortir

Postorder traversal of binary tree is: 4 5 2 6 3 1

Explication:

Comment fonctionne le parcours de vente par correspondance

Analyse de complexité :

Complexité temporelle : O(N) où N est le nombre total de nœuds. Parce qu'il traverse tous les nœuds au moins une fois.
Espace auxiliaire : O(1) si aucun espace de pile de récursion n’est pris en compte. Sinon, O(h) où h est la hauteur de l'arbre

Au pire des cas, h peut être le même que N (quand l'arbre est un arbre de travers)
Dans le meilleur des cas, h peut être le même que calme (quand l'arbre est un arbre complet)

Cas d'utilisation de Postorder Traversal :

Certains cas d'utilisation du parcours post-commande sont :

Ceci est utilisé pour la suppression d’arborescence.
Il est également utile d'obtenir l'expression suffixe à partir d'un arbre d'expression.

Articles Liés:

Types de traversées d'arbres
Parcours itératif de post-commande (en utilisant deux piles)
Parcours itératif de post-commande (en utilisant une pile)
Postcommande d'Arbre Binaire sans récursion et sans pile
Trouver le parcours post-commande de BST à partir du parcours de précommande
Traversée de Morris pour la vente par correspondance
Imprimer le parcours post-commande à partir du parcours pré-commande et in-order