Binary tree level-order-traversal

Drei Arten von Baum-traversalen sind inorder, preorder, und post bestellen.

Einem vierten, weniger Häufig verwendet, traversal ist level-order-traversal. In einem
level-order traveresal, werden alle Knoten in der Tiefe "d" verarbeitet werden, bevor
jeder Knoten in der Tiefe d + 1. Level-order-traversal unterscheidet sich von den anderen
traversalen, dass es nicht geschieht rekursiv; eine Warteschlange verwendet wird,
statt der implizite stack Rekursion.

Meine Fragen zu obigen textausschnitt sind

Warum die level-order traversals sind nicht erfolgt rekursiv?
Wie die Warteschlange wird verwendet in level order traversal? Antrag Klärung mit Pseudo-code, hilfreich sein wird.

Dank!

InformationsquelleAutor venkysmarty | 2011-09-05

algorithm

14

Level-order-traversal ist eigentlich ein BFS, die nicht von Natur aus rekursiv. Es nutzt Warteschlange statt Stack zu halten, die nächsten Eckpunkte, die geöffnet werden soll. Der Grund dafür ist in diesem traversal, die Sie öffnen möchten, die Knoten in einem FIFO, um, statt eine LIFO Ordnung, erhalten durch die Rekursion

wie ich bereits erwähnt, das Niveau, um tatsächlich eine BFS, und seine [BFS] pseudo-code [entnommen aus wikipedia] ist:
```
1  procedure BFS(Graph,source):
2      create a queue Q
3      enqueue source onto Q
4      mark source
5      while Q is not empty:
6          dequeue an item from Q into v
7          for each edge e incident on v in Graph:
8              let w be the other end of e
9              if w is not marked:
10                 mark w
11                 enqueue w onto Q
```
(*) in einen Baum, Markierung der Scheitelpunkte ist auch nicht nötig, da Sie nicht auf die gleichen Knoten in 2 verschiedene Wege.

InformationsquelleAutor amit

void levelorder(Node *n)
{    queue < Node * >q;

     q.push(n);


     while(!q.empty())
     {
             Node *node = q.front();
             cout<<node->value;
             q.pop();
             if(node->left != NULL)
             q.push(node->left);
             if (node->right != NULL)
             q.push(node->right);

     }

}

InformationsquelleAutor abaid

0

Finden Sie eine gute übersicht in Wikipedia sogar mit code-snippets.

InformationsquelleAutor Jiri Kriz
0

Statt einer Warteschlange, die ich verwendet eine Karte, um dieses Problem zu lösen. Werfen Sie einen Blick, wenn Sie interessiert sind. Wie ich einem postorder-traversal, ich behaupte die Tiefe, in der jeder Knoten positioniert ist und verwenden Sie diese Tiefe als Schlüssel in einer map zu sammeln, die Werte in der gleichen Ebene

class Solution { public: map<int, vector<int> > levelValues; void recursivePrint(TreeNode *root, int depth){ if(root == NULL) return; if(levelValues.count(root->val) == 0) levelValues.insert(make_pair(depth, vector<int>())); levelValues[depth].push_back(root->val); recursivePrint(root->left, depth+1); recursivePrint(root->right, depth+1); } vector<vector<int> > levelOrder(TreeNode *root) { recursivePrint(root, 1); vector<vector<int> > result; for(map<int,vector<int> >::iterator it = levelValues.begin(); it!= levelValues.end(); ++it){ result.push_back(it->second); } return result; } };

Die gesamte Lösung kann hier gefunden werden - http://ideone.com/zFMGKU
Die Lösung wird ein Vektor von Vektoren mit jeder innere Vektor, der die Elemente im Baum in der richtigen Reihenfolge.

können Sie versuchen, die Lösung hier - https://oj.leetcode.com/problems/binary-tree-level-order-traversal/

Und, wie Sie sehen können, können wir auch dies rekursiv in der gleichen Zeit, Raum und Komplexität, mit der die Warteschlange Lösung!

InformationsquelleAutor Ravi Sankar Raju

https://github.com/arun2pratap/data-structure/blob/master/src/main/java/com/ds/tree/binarytree/BinaryTree.java

für die vollständige Blick für den obigen link.

 public void levelOrderTreeTraversal(List<Node<T>> nodes){
    if(nodes == null || nodes.isEmpty()){
        return;
    }
    List<Node<T>> levelNodes = new ArrayList<>();
    nodes.stream().forEach(node -> {
        if(node != null) {
            System.out.print(" " + node.value);
            levelNodes.add(node.left);
            levelNodes.add(node.right);
        }
    });
    System.out.println("");
    levelOrderTreeTraversal(levelNodes);
}