Gegeben eine n-ärer Baum Die Aufgabe besteht darin, positive Knotenwerte zu finden Tiefe des Baumes.
Notiz: Ein n-ärer Baum ist ein Baum, den jeder Knoten haben kann null oder mehr untergeordnete Knoten. Im Gegensatz zu einem Binärbaum, der höchstens zwei Kinder pro Knoten hat (links und rechts) Der n-äre Baum ermöglicht dies mehrere Filialen oder Kinder für jeden Knoten.
Beispiele:
Eingang:
Ausgabe: 3
Erläuterung: Der längste Pfad von der Wurzel (Knoten 81) zu einem Blatt ist entweder 81 -> 26 -> 95 oder 81 -> 26 -> 86, was eine maximale Tiefe von 3 ergibt.Eingang:
Ausgabe: 2
Erläuterung: Der längste Pfad von der Wurzel (Knoten 4) zu einem Blatt (Knoten 5 oder 7) beträgt 2, da nur zwei Durchquerungsebenen erforderlich sind.java scan.nextstring
Ansatz:
Die Idee ist, die zu berechnen Tiefe eines N-ary-Baums rekursiv initialisieren Sie die maximale Tiefe als 0 dann rekursiv berechnen Tiefe für jedes Kind und behalten Sie den Überblick höchste Tiefe angetroffen. Zum Schluss hinzufügen 1 bis zur maximalen Tiefe (für den aktuellen Knoten) und geben Sie die zurück Ergebnis . Dieser Ansatz stellt sicher, dass wir das finden längster Weg von der Wurzel bis zu einem beliebigen Blattknoten.
Der N-Ary-Baum kann wie ein normaler Baum durchlaufen werden. Wir müssen lediglich alle Kinder eines bestimmten Knotens berücksichtigen und diese Funktion auf jedem Knoten rekursiv aufrufen.
C++// C++ Code to find the depth of an N-ary tree #include
// Java Code to find the depth of an N-ary tree import java.util.*; class Node { int data; List<Node> children; Node(int val) { data = val; children = new ArrayList<>(); } } // Recursive function to calculate // maximum depth class GfG { static int maxDepth(Node root) { // If the node is null depth is 0 if (root == null) { return 0; } int depth = 0; // Recur for all children and find // the maximum depth for (Node child : root.children) { depth = Math.max(depth maxDepth(child)); } // Add 1 to include the current node // in the depth count return depth + 1; } public static void main(String[] args) { // Representation of given N-ary tree // 1 // / | // 2 3 4 // / // 5 6 Node root = new Node(1); root.children.add(new Node(2)); root.children.add(new Node(3)); root.children.add(new Node(4)); root.children.get(0).children.add(new Node(5)); root.children.get(2).children.add(new Node(6)); System.out.println(maxDepth(root)); } }
# Python Code to find the depth # of an N-ary tree class Node: def __init__(self val): self.data = val self.children = [] # Recursive function to calculate # maximum depth def max_depth(root): # If the node is None depth is 0 if not root: return 0 depth = 0 # Recur for all children and # find the maximum depth for child in root.children: depth = max(depth max_depth(child)) # Add 1 to include the current # node in the depth count return depth + 1 if __name__ == '__main__': # Representation of given N-ary tree # 1 # / | # 2 3 4 # / # 5 6 root = Node(1) root.children.append(Node(2)) root.children.append(Node(3)) root.children.append(Node(4)) root.children[0].children.append(Node(5)) root.children[2].children.append(Node(6)) print(max_depth(root))
// C# Code to find the depth of an N-ary tree using System; using System.Collections.Generic; class Node { public int data; public List<Node> children; public Node(int val) { data = val; children = new List<Node>(); } } // Recursive function to calculate // maximum depth class GfG { static int MaxDepth(Node root) { // If the node is null depth is 0 if (root == null) { return 0; } int depth = 0; // Recur for all children and find the maximum depth foreach (Node child in root.children) { depth = Math.Max(depth MaxDepth(child)); } // Add 1 to include the current // node in the depth count return depth + 1; } static void Main(string[] args) { // Representation of given N-ary tree // 1 // / | // 2 3 4 // / // 5 6 Node root = new Node(1); root.children.Add(new Node(2)); root.children.Add(new Node(3)); root.children.Add(new Node(4)); root.children[0].children.Add(new Node(5)); root.children[2].children.Add(new Node(6)); Console.WriteLine(MaxDepth(root)); } }
// JavaScript Code to find the depth // of an N-ary tree class Node { constructor(val) { this.data = val; this.children = []; } } // Recursive function to calculate // maximum depth function maxDepth(root) { // If the node is null depth is 0 if (!root) { return 0; } let depth = 0; // Recur for all children and find // the maximum depth for (let child of root.children) { depth = Math.max(depth maxDepth(child)); } // Add 1 to include the current node // in the depth count return depth + 1; } // Representation of given N-ary tree // 1 // / | // 2 3 4 // / // 5 6 const root = new Node(1); root.children.push(new Node(2)); root.children.push(new Node(3)); root.children.push(new Node(4)); root.children[0].children.push(new Node(5)); root.children[2].children.push(new Node(6)); console.log(maxDepth(root));
Ausgabe
3
Zeitkomplexität: O(n), da jeder Knoten einmal besucht wird, wobei n die Gesamtzahl der Knoten im N-fachen Baum ist.
Hilfsraum: O(h) wobei h die Höhe des Baums aufgrund der Verwendung des rekursiven Aufrufstapels ist.