ENNAKKOTILAA BINAARIPUUN TRAVERSAL - TECHCODEVIEW.COM

Ennakkotilaa läpikulku määritellään tyypiksi puun läpikulku joka noudattaa juuri-vasen-oikea -käytäntöä, jossa:

Alipuun juurisolmussa käydään ensin.
Sitten vasen alipuu ajetaan läpi.
Lopulta oikea alipuu ajetaan läpi.

Ennakkotilaa läpikulku

Algoritmi binaaripuun ennakkotilauskierrokselle

Ennakkotilauksen läpikäymisen algoritmi näkyy seuraavasti:

Ennakkotilaus (juuri):

Noudata vaiheita 2–4, kunnes root != NULL
Kirjoita root -> data
Ennakkotilaus (juuri -> vasen)
Ennakkotilaa (root -> oikealle)
Lopeta silmukka

Miten Binary Tree Preorder Traversal toimii?

Harkitse seuraavaa puuta:

paras hentai

Esimerkki binaaripuusta

arraylist lajiteltu

Jos suoritamme ennakkotilauksen läpikäynnin tässä binääripuussa, läpikulku on seuraava:

Vaihe 1: Aluksi käydään juurissa, eli solmussa 1.

Solmussa 1 käydään

Vaihe 2: Tämän jälkeen poikki vasemmassa alipuussa. Nyt käydään vasemman alipuun juuressa, eli solmussa 2 käydään.

Node 2 on vierailtu
luokka vs objekti javassa

Vaihe 3: Jälleen ajetaan solmun 2 vasen alipuu ja vieraillaan tämän alipuun juurissa, eli solmussa 4.

Solmussa 4 käydään

Vaihe 4: 4:n alipuuta ei ole ja solmun 2 vasemmassa alipuussa käydään. Joten nyt ajetaan solmun 2 oikean alipuun läpi ja vierataan tämän alipuun juurissa, eli solmussa 5.

Node 5 on vierailtu

Vaihe 5: Solmun 1 vasemmassa alipuussa käydään. Joten nyt ajetaan solmun 1 oikea alipuu ja käydään juurisolmussa eli solmussa 3.
kuinka löytää estetyt numerot Androidista

Solmussa 3 käydään

Vaihe 6: Solmussa 3 ei ole vasenta alipuuta. Siten alipuun oikeanpuoleisen alipuun läpi käydään ja alipuun juurissa eli solmussa 6 käydään. Sen jälkeen ei ole solmua, jota ei olisi vielä kuljetettu. Joten läpikulku päättyy.

Koko puussa käydään

Joten solmujen läpikulkujärjestys on 1 -> 2 -> 4 -> 5 -> 3 -> 6 .

Ohjelma binaaripuun ennakkotilauksen läpikäymisen toteuttamiseksi

Alla on ennakkotilauksen läpikäymisen kooditoteutus:

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->tiedot<< ' ';  // Recur on left subtree  printPreorder(node->vasen);  // Toista oikealla alipuulla printPreorder(node->right); } // Ohjainkoodi int main() { struct Solmu* root = new Node(1);  juuri->vasen = uusi solmu(2);  juuri->oikea = uusi solmu(3);  juuri->vasen->vasen = uusi solmu(4);  juuri->vasen->oikea = uusi solmu(5);  juuri->oikea->oikea = uusi solmu(6);  // Funktion kutsu<< '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);  } }>

Python 3

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

Lähtö

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

Selitys:

Miten ennakkotilauksen läpikulku toimii

Monimutkaisuusanalyysi:

Aika monimutkaisuus: O(N) missä N on solmujen kokonaismäärä. Koska se kulkee kaikkien solmujen läpi vähintään kerran.
Aputila:

monisäikeinen java

O(1) jos rekursiopinotilaa ei oteta huomioon.
Muuten, Vai niin) missä h on puun korkeus
Pahimmassa tapauksessa h voi olla sama kuin N (kun puu on vinossa puu)
Parhaassa tapauksessa h voi olla sama kuin rauhoittaa (kun puu on täydellinen puu)

Ennakkotilauksen läpikäymisen käyttötapaukset:

Jotkut ennakkotilauksen läpikulun käyttötapaukset ovat:

Tätä käytetään usein puun kopion luomiseen.
On myös hyödyllistä saada etuliitelauseke lausekepuusta.

Aiheeseen liittyvät artikkelit:

Puun läpikulkutyypit
Iteratiivinen ennakkotilauskierros
Tarkista, voiko annettu taulukko edustaa BST:n ennakkotilausta
Ennakkotilaus inorder- ja postorder-läpikuluista
Etsi n:s solmu binääripuun ennakkotilauksen läpikäymisestä
Ennakkotilaa N-lukuisen puun läpikulku

TechCodeview