TRAVERSAL OF BINARY TREE VOORAF BESTELLEN - TECHCODEVIEW.COM

Doortocht vooraf bestellen wordt gedefinieerd als een soort boom doorkruisen dat het Root-Links-Rechts-beleid volgt, waarbij:

Het hoofdknooppunt van de subboom wordt eerst bezocht.
Vervolgens wordt de linker deelboom doorlopen.
Eindelijk wordt de rechter deelboom doorlopen.

Doortocht vooraf bestellen

Algoritme voor pre-order-doorgang van binaire boom

Het algoritme voor het doorlopen van pre-orders wordt als volgt weergegeven:

Voorbestelling(root):

Volg stap 2 tot en met 4 tot root != NULL
Schrijf root -> gegevens
Voorbestellen (root -> links)
Voorbestellen (root -> rechts)
Einde lus

Hoe werkt Preorder Traversal of Binary Tree?

Beschouw de volgende boom:

wat is een Linux-bestandssysteem

Voorbeeld van binaire boom

Als we een preorder-traversal in deze binaire boom uitvoeren, zal de traversal als volgt zijn:

Stap 1: In eerste instantie wordt de root bezocht, dus knooppunt 1.

Knooppunt 1 wordt bezocht
tekenreeks subtekenreeks java

Stap 2: Ga hierna door de linker subboom. Nu wordt de wortel van de linker subboom bezocht, d.w.z. knooppunt 2 wordt bezocht.

Knooppunt 2 wordt bezocht

Stap 3: Opnieuw wordt de linker subboom van knooppunt 2 doorlopen en wordt de wortel van die subboom, d.w.z. knooppunt 4, bezocht.

Knooppunt 4 wordt bezocht

Stap 4: Er is geen subboom van 4 en de linker subboom van knooppunt 2 wordt bezocht. Dus nu zal de rechter subboom van knooppunt 2 worden doorlopen en de wortel van die subboom, d.w.z. knooppunt 5, zal worden bezocht.

Knooppunt 5 wordt bezocht

Stap 5: De linker deelboom van knooppunt 1 wordt bezocht. Dus nu wordt de rechter subboom van knooppunt 1 doorlopen en wordt het hoofdknooppunt, d.w.z. knooppunt 3, bezocht.
cdr volledige vorm

Knooppunt 3 wordt bezocht

Stap 6: Knooppunt 3 heeft geen linkersubboom. Dus de rechter subboom zal worden doorlopen en de wortel van de subboom, d.w.z. knooppunt 6, zal worden bezocht. Daarna is er geen knooppunt dat nog niet is doorlopen. De doortocht eindigt dus.

De volledige boom wordt bezocht

De volgorde van het doorlopen van knooppunten is dus 1 -> 2 -> 4 -> 5 -> 3 -> 6 .

Programma om pre-order traversal van binaire boom te implementeren

Hieronder vindt u de code-implementatie van de pre-order-traversal:

C++

 // C++ program for preorder 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 preorder traversal void printPreorder(struct Node* node) {  if (node == NULL)  return;  // Deal with the node  cout << node->gegevens<< ' ';  // Recur on left subtree  printPreorder(node->links);  // Terugkomend op rechter subboom printPreorder(node->right); } // Stuurprogrammacode int main() { struct Node* root = new Node(1);  root->left = nieuw knooppunt(2);  root->right = nieuw knooppunt(3);  root->left->left = nieuw knooppunt(4);  root->links->rechts = nieuw knooppunt(5);  root->right->right = nieuw knooppunt(6);  // Functieoproep cout<< 'Preorder traversal of binary tree is: 
';  printPreorder(root);  return 0; }>

Java

 // Java program for preorder traversals class Node {  int data;  Node left, right;  public Node(int item) {  data = item;  left = right = null;  } } class BinaryTree {  Node root;  BinaryTree() {  root = null;  }  // Function to print preorder traversal  void printPreorder(Node node) {  if (node == null)  return;  // Deal with the node  System.out.print(node.data + ' ');  // Recur on left subtree  printPreorder(node.left);  // Recur on right subtree  printPreorder(node.right);  }  // Driver code  public static void main(String[] args) {  BinaryTree tree = new BinaryTree();  // Constructing the binary tree  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);  // Function call  System.out.println('Preorder traversal of binary tree is: ');  tree.printPreorder(tree.root);  } }>

Python3

 # Python program for preorder 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 preorder traversal def printPreorder(node): if node is None: return # Deal with the node print(node.data, end=' ') # Recur on left subtree printPreorder(node.left) # Recur on right subtree printPreorder(node.right) # 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('Preorder traversal of binary tree is:') printPreorder(root)>

 // C# program for preorder 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;  } } // Class to print preorder traversal public class BinaryTree {  // Function to print preorder traversal  public static void printPreorder(Node node)  {  if (node == null)  return;  // Deal with the node  Console.Write(node.data + ' ');  // Recur on left subtree  printPreorder(node.left);  // Recur on right subtree  printPreorder(node.right);  }  // Driver code  public static void 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.right = new Node(6);  // Function call  Console.WriteLine(  'Preorder traversal of binary tree is: ');  printPreorder(root);  } } // This code is contributed by Susobhan Akhuli>

Javascript

 // Structure of a Binary Tree Node class Node {  constructor(v) {  this.data = v;  this.left = null;  this.right = null;  } } // Function to print preorder traversal function printPreorder(node) {  if (node === null) {  return;  }  // Deal with the node  console.log(node.data);  // Recur on left subtree  printPreorder(node.left);  // Recur on right subtree  printPreorder(node.right); } // Driver code function main() {  const 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('Preorder traversal of binary tree is:');  printPreorder(root); } main();>

Uitvoer

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

Uitleg:

Hoe pre-order traversal werkt

Complexiteitsanalyse:

Tijdcomplexiteit: O(N) waarbij N het totale aantal knooppunten is. Omdat het alle knooppunten minstens één keer doorkruist.
Hulpruimte:

pete davidson leeftijd

O(1) als er geen rekening wordt gehouden met recursiestapelruimte.
Anders, Oh) waarbij h de hoogte van de boom is
In het slechtste geval, H kan hetzelfde zijn als N (als de boom een scheve boom is)
In het beste geval, H kan hetzelfde zijn als kalm (als de boom een complete boom is)

Gebruiksscenario's van Preorder Traversal:

Enkele gebruiksscenario's van pre-order traversal zijn:

Dit wordt vaak gebruikt voor het maken van een kopie van een boom.
Het is ook handig om de voorvoegselexpressie uit een expressieboom te halen.

Gerelateerde artikelen:

Soorten boomtraversal
Iteratieve pre-order-traversal
Controleer of de gegeven array de pre-order traversal van BST kan vertegenwoordigen
Pre-order van inorder- en postorder-traversals
Vind het n-de knooppunt in de preorder-doorgang van een binaire boom
Doortocht door een N-aire boom vooraf bestellen

TechCodeview