Abrufen einer Binary-Tree-Knoten der Tiefe nicht rekursiv

Kann jeder Punkt aus, um die Tiefe eines Knotens in einem Binären Baum (nicht ein symmetrisches, oder BST) ohne Verwendung von Rekursion? Idealerweise in Java/C/C#

Den Knoten wird dargestellt als:

class Node
{
  Node Left;
  Node Right;
  string Value;
  int Depth;
}

Mit Niveau, Um mit einer FIFO-Liste war mein Erster Gedanke, aber ich war ratlos bei der Erkennung, wenn das Niveau ändert sich, insbesondere bei unsymmetrischen Bäumen.

Rekursion ist der einfachste Weg, dies zu tun, was ist der Grund, warum Sie es vermeiden wollen?
Ist das Feld Tiefe der Abstand von der Wurzel, oder aus dem hintersten Kind?
Kirschstein: Es gibt Gründe, um zu vermeiden, rekursive Aufrufe auf Plattformen mit begrenzten Ressourcen (z.B. embedded systems). Eine nicht rekursive Algorithmus mit einem Konstanten memory foot print ist oft notwendig.
Worrier: Ah, ich sehe. Dank
Die Rekursion Beiträge, die ich gelesen habe, SO geben Sie den Rat, dass die Rekursion sollte verwendet werden, für maximal 10 Ebenen. 10 Ebenen in einem vollständigen Baum ist 1024 Elemente, also bin ich mal gespannt, wie Sie es tun würde, für mehr als das (was ich davon ausgehen, andere Bäume basierend auf den Binären Baum verwenden würde, jedoch stets symmetrisch)

InformationsquelleAutor Chris S | 2009-06-17

6

Ich nehme an, du meinst das ausfüllen der Wert für die Tiefe auf Knoten und/oder der Suche nach max Tiefe. Eine Möglichkeit dazu wäre die Verwendung von zwei Listen, und dabei die Ebene, um wie vorgeschlagen. Es wäre ähnlich:
```
int level=0;
List<Node> currentLevel = new List<Node>{root};
while(currentLevel.Count != 0)
{
  List<Node> nextLevel = new List<Node>{};
  foreach(Node node in currentLevel)
  {
    if(node.Right!=null) nextLevel.Add(node.Right);
    if(node.Left != null) nextLevel.Add(node.Left);
    node.Depth=level;
  }
  level++;
  currentLevel=nextLevel;
}
```
Im Grunde, Sie aufzuzählen, jeder Knoten auf einer gegebenen Ebene, dann finden Sie jeden Knoten auf der nächsten Ebene, bis Sie aus dem Knoten/Ebenen. Klar, Liste ersetzt werden könnte mit gerade ungefähr jeder Liste wie Datenstrukturen (verkettete Listen, Queue, etc.). Und der Letzte Wert der 'Ebene' wäre max depth + 1. Ich vermute.

Einer weiteren Aufklärung basiert auf re-Lektüre der Frage, wenn Sie sind auf der Suche nach einem Knoten mit einem bestimmten Wert, und wollen zu finden, seine Tiefe, würden Sie die foreach-Schleife zum zählen 'wenn(Knoten.Wert==searchValue) return level;'. Und, technisch gesehen, wenn Sie sind auf der Suche nach einem bestimmten Wert, die Sie nicht tun sollten eine Level-Order-Traversal, sondern eher eine Suche nach dem Wert mit entsprechenden Binären Baum Eigenschaften (z.B. val < currentNode.Wert gehe nach Links else goto rechts), und die Verfolgung Ihrer Tiefe. Wenn Sie nur die Knoten und finden wollen, seine Tiefe, würden Sie entweder müssen zum ausführen einer binären Suche für die Knoten von der Wurzel, oder würden Sie brauchen, um zu verfolgen die Knoten parent.

InformationsquelleAutor CoderTao

Können Sie implementieren resursive Methode mit einem stack, das ist, wie resursion funktioniert sowieso. Stellen Sie sich Ihr resursive Funktion aussieht

function int getDepth (Node head, string val)
{
    if (head == NULL)
        return -1;

    if (val == head.Value)
        return head.Depth;

    return MAX(getDepth(head.Left, val), getDepth(head.Right, val);
}

Nicht-resursive Funktion sieht so etwas wie

function int getDepth (Node head, string val)
{
    Stack s = new Stack();

    s.push(head);

    while(s.count > 0)
    {
        Node temp = s.pop();

        if (temp != NULL)
        {
            if (s.Value == val)
                return s.Depth;
            else
            {
                s.push(temp.Left);
                s.push(temp.Right);
            }
        }

    }


    return -1;
}

EDIT:

Diese Funktion stellt die Tiefe für jeden Knoten

function void setDepth (Node head)
{
    Stack s = new Stack();

    head.Depth = 0;
    s.push(head);

    while(s.count > 0)
    {
        Node temp = s.pop();

        if (temp != NULL)
        {
            if (temp.Left != NULL)
            {
                temp.Left.Depth = temp.Depth + 1;
                s.push(temp.Left);
            }

            if (temp.Right != NULL)
            {
                temp.Right.Depth = temp.Depth + 1;
                s.push(temp.Right);
            }
        }

    }

}

Ich bin nach der Einstellung der Tiefe zu
+1 für die Antwort. Es muss einen besseren Weg, um die Tiefe, ohne dass jedem Knoten die Tiefe, Eigentum, obwohl, Recht?
ja. Sie können ändern Sie die rekursive Funktion zu Funktion int getDepth (Knoten head, string val, int Tiefe). Pass in die Tiefe+1, um die rekursiven Aufrufe.

InformationsquelleAutor David

Hier ist eine einfachere Lösung, denke ich. Wenn die Struktur der Daten erlaubt, für eine beliebige Anzahl von Kindern, die diese Lösung kann leicht geändert werden, für diesen Fall zu:

int getDepthNoRecursion(Node n) {
  if(n == null) {
    return 0;
  }
  int retval = 0;
  n.depth = 1;
  Stack s = new Stack();
  s.push(n);
  while(!s.isEmpty()) {
    Node n = (Node) s.pop();
    int currDepth = n.depth;
    if(currDepth > retval) {
      retval = currDepth;
    }
    if(n.left != null) {
      n.left.depth = currDepth + 1;
      s.push(n.left);
    }
    if(n.right != null) {
      n.right.depth = currDepth + 1;
      s.push(n.right);
    }
  }
  return retval;
}
class Node {
  Node left;
  Node right;
  int depth = 0;
}

InformationsquelleAutor user388932

Hier ist die effizienteste Lösung, die ich mir ausgedacht habe (C++). Der trick ist, verwenden Sie eine zweite Warteschlange zum speichern der Kinder aller Knoten auf der aktuellen Ebene. Dies funktioniert für symmetrische und unsymmetrische binären Bäumen.

template <class T>
struct TreeNode {
  TreeNode<T>* left_;
  TreeNode<T>* right_;
  T* data_;
};

template <class T>
int find_depth( const TreeNode<T>* root ) {   
  if ( root == NULL ) return 0;
  int depth = 0;
  std::queue<const TreeNode<T>*>* q1 = new std::queue<const TreeNode<T>*>;
  std::queue<const TreeNode<T>*>* q2 = new std::queue<const TreeNode<T>*>;
  q1->push( root );
  while ( !q1->empty() ) {
    //At the top of the outer loop q1 contains a complete horizontal level of the tree                                                                                  
    depth++;

    //Swap the queue pointers to avoid any deep copies                                                                                                                  
    std::queue<const TreeNode<T>*>* tmpQ = q2;
    q2 = q1;
    q1 = tmpQ;

    //Iterate over this level, inserting all children into q1                                                                                                           
    while( !q2->empty() ) {
      const TreeNode<T>* node = q2->front();
      if ( node->left_ != NULL ) q1->push( node->left_ );
      if ( node->right_ != NULL ) q1->push( node->right_ );
      q2->pop();
    }
  }
  delete q1;
  delete q2;
  return depth;
}

InformationsquelleAutor hifier

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.