logo

TechCodeview

Vind de hoogte van een speciale binaire boom waarvan de bladknooppunten zijn verbonden

Gegeven een speciale binaire boom waarvan bladknopen zijn verbonden om een ​​te vormen circulaire dubbel gelinkte lijst de taak is om de hoogte van de boom.

Voorbeelden:



Invoer:

Vind-hoogte-van-een-speciale-binaire-boom-waarvan-de-bladknooppunten-verbonden-2 zijn' title=

Uitgang: 2
Uitleg: De hoogte van de binaire boom na herkenning van de bladknooppunten is 2. In de bovenstaande binaire boom zijn 6, 5 en 4 bladknooppunten en zij vormen een cirkelvormige, dubbel gekoppelde lijst. Hier zal de linkeraanwijzer van het bladknooppunt fungeren als een eerdere aanwijzer van een cirkelvormige, dubbel gekoppelde lijst en de rechteraanwijzer zal fungeren als de volgende aanwijzer van een cirkelvormige, dubbel gekoppelde lijst. 

factoriële java

Invoer:



Vind-hoogte-van-een-speciale-binaire-boom-waarvan-bladknooppunten-verbonden-1 zijn' loading='lazy' title=

Uitgang: 1
Uitleg: De hoogte van de binaire boom na herkenning van de bladknooppunten is 1. In de bovenstaande binaire boom zijn 2 en 3 bladknooppunten en zij vormen een cirkelvormige, dubbel gekoppelde lijst.

Benadering :

Het idee is om te volgen soortgelijke aanpak zoals wij dat ook doen het vinden van de hoogte van een normale binaire boom . Wij recursief berekenen hoogte van links en rechts subbomen van een knooppunt en wijs toe hoogte naar het knooppunt als maximaal van de lengtes van twee kinderen plus 1. Maar linker- en rechterkind van a blad knooppunt zijn nul voor normale binaire bomen. Maar hier is het bladknooppunt een cirkelvormig, dubbel gekoppeld lijstknooppunt. Dus als een knooppunt een bladknooppunt is, controleren we of knooppunt is links en rechts wijst naar de knooppunt en zijn rechts is links wijst ook op de knooppunt zelf.



C++ 
// C++ program to calculate height of a special tree // whose leaf nodes forms a circular doubly linked list #include    using namespace std; class Node { public:  int data;  Node *left *right;  Node(int x) {  data = x;  left = nullptr;  right = nullptr;  } }; // function to check if given  // node is a leaf node or node bool isLeaf(Node* node) {    // For a node to be a leaf node it should  // satisfy the following two conditions:  // 1. Node's left's right pointer should be   // current node.  // 2. Node's right's left pointer should be   // current node.    // If one condition is met it is guaranteed  // that the other consition is also true.  return node->left && node->left->right == node  && node->right && node->right->left == node; } // Compute the height of a tree  int findTreeHeight(Node* node) {    // if node is NULL return -1.  if (node == nullptr)  return -1;  // if node is a leaf node return 0  if (isLeaf(node))  return 0;  // compute the depth of each subtree  // and take maximum  return 1 + max(findTreeHeight(node->left)   findTreeHeight(node->right)); } int 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->left->left->left = new Node(6);  // Given tree contains 3 leaf nodes  Node* l1 = root->left->left->left;  Node* l2 = root->left->right;  Node* l3 = root->right;  // create circular doubly linked list out of  // leaf nodes of the tree  // set next pointer of linked list  l1->right = l2 l2->right = l3 l3->right = l1;  // set prev pointer of linked list  l3->left = l2 l2->left = l1 l1->left = l3;  cout << findTreeHeight(root);  return 0; }
C 
// C program to calculate height of a special tree // whose leaf nodes forms a circular doubly linked list #include  #include  struct Node {  int data;  struct Node *left *right; }; // function to check if given  // node is a leaf node or node int isLeaf(struct Node* node) {    // For a node to be a leaf node it should  // satisfy the following two conditions:  // 1. Node's left's right pointer should be   // current node.  // 2. Node's right's left pointer should be   // current node.    // If one condition is met it is guaranteed  // that the other condition is also true.  return node->left && node->left->right == node  && node->right && node->right->left == node; } // Compute the height of a tree  int findTreeHeight(struct Node* node) {    // if node is NULL return -1.  if (node == NULL)  return -1;  // if node is a leaf node return 0  if (isLeaf(node))  return 0;  // compute the depth of each subtree and take maximum  int leftDepth = findTreeHeight(node->left);  int rightDepth = findTreeHeight(node->right);  return 1 + (leftDepth > rightDepth ? leftDepth : rightDepth); } struct Node* createNode(int data) {  struct Node* newNode =   (struct Node*)malloc(sizeof(struct Node));  newNode->data = data;  newNode->left = NULL;  newNode->right = NULL;  return newNode; } int main() {    struct Node* root = createNode(1);  root->left = createNode(2);  root->right = createNode(3);  root->left->left = createNode(4);  root->left->right = createNode(5);  root->left->left->left = createNode(6);  // Given tree contains 3 leaf nodes  struct Node* l1 = root->left->left->left;  struct Node* l2 = root->left->right;  struct Node* l3 = root->right;  // create circular doubly linked list out of  // leaf nodes of the tree  // set next pointer of linked list  l1->right = l2 l2->right = l3 l3->right = l1;  // set prev pointer of linked list  l3->left = l2 l2->left = l1 l1->left = l3;  printf('%d' findTreeHeight(root));  return 0; }
Java 
// Java program to calculate height of a special tree // whose leaf nodes forms a circular doubly linked list class Node {  int data;  Node left right;  Node(int x) {  data = x;  left = null;  right = null;  } } class GfG {  // function to check if given   // node is a leaf node or node  static boolean isLeaf(Node node) {    // For a node to be a leaf node it should  // satisfy the following two conditions:  // 1. Node's left's right pointer should be   // current node.  // 2. Node's right's left pointer should be   // current node.    // If one condition is met it is guaranteed  // that the other condition is also true.  return node.left != null && node.left.right == node  && node.right != null && node.right.left == node;  }  // Compute the height of a tree   static int findTreeHeight(Node node) {    // if node is NULL return -1.  if (node == null)  return -1;  // if node is a leaf node return 0  if (isLeaf(node))  return 0;  // compute the depth of each subtree and take maximum  return 1 + Math.max(findTreeHeight(node.left)   findTreeHeight(node.right));  }  public static void main(String[] args) {  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.left.left.left = new Node(6);  // Given tree contains 3 leaf nodes  Node l1 = root.left.left.left;  Node l2 = root.left.right;  Node l3 = root.right;  // create circular doubly linked list out of  // leaf nodes of the tree  // set next pointer of linked list  l1.right = l2;  l2.right = l3;  l3.right = l1;  // set prev pointer of linked list  l3.left = l2;  l2.left = l1;  l1.left = l3;  System.out.println(findTreeHeight(root));  } }
Python 
# Python program to calculate height of a special tree # whose leaf nodes forms a circular doubly linked list class Node: def __init__(self data): self.data = data self.left = None self.right = None # function to check if given  # node is a leaf node or node def isLeaf(node): # For a node to be a leaf node it should # satisfy the following two conditions: # 1. Node's left's right pointer should be  # current node. # 2. Node's right's left pointer should be  # current node. # If one condition is met it is guaranteed # that the other condition is also true. return (node.left and node.left.right == node and node.right and node.right.left == node) # Compute the height of a tree  def findTreeHeight(node): # if node is NULL return -1. if node is None: return -1 # if node is a leaf node return 0 if isLeaf(node): return 0 # compute the depth of each subtree and take maximum return 1 + max(findTreeHeight(node.left) findTreeHeight(node.right)) 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.left.left.left = Node(6) # Given tree contains 3 leaf nodes l1 = root.left.left.left l2 = root.left.right l3 = root.right # create circular doubly linked list out of # leaf nodes of the tree # set next pointer of linked list l1.right = l2 l2.right = l3 l3.right = l1 # set prev pointer of linked list l3.left = l2 l2.left = l1 l1.left = l3 print(findTreeHeight(root))
C# 
// C# program to calculate height of a special tree // whose leaf nodes forms a circular doubly linked list using System; class Node {  public int data;  public Node left right;  public Node(int x) {  data = x;  left = null;  right = null;  } } class GfG {  // function to check if given   // node is a leaf node or node  static bool isLeaf(Node node) {    // For a node to be a leaf node it should  // satisfy the following two conditions:  // 1. Node's left's right pointer should be   // current node.  // 2. Node's right's left pointer should be   // current node.    // If one condition is met it is guaranteed  // that the other condition is also true.  return node.left != null && node.left.right == node  && node.right != null && node.right.left == node;  }  // Compute the height of a tree   static int findTreeHeight(Node node) {    // if node is NULL return -1.  if (node == null)  return -1;  // if node is a leaf node return 0  if (isLeaf(node))  return 0;  // compute the depth of each subtree and take maximum  return 1 + Math.Max(findTreeHeight(node.left) findTreeHeight(node.right));  }  static void Main(string[] args) {  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.left.left.left = new Node(6);  // Given tree contains 3 leaf nodes  Node l1 = root.left.left.left;  Node l2 = root.left.right;  Node l3 = root.right;  // create circular doubly linked list out of  // leaf nodes of the tree  // set next pointer of linked list  l1.right = l2;  l2.right = l3;  l3.right = l1;  // set prev pointer of linked list  l3.left = l2;  l2.left = l1;  l1.left = l3;  Console.WriteLine(findTreeHeight(root));  } }
JavaScript 
// JavaScript program to calculate height of a special tree // whose leaf nodes forms a circular doubly linked list class Node {  constructor(data) {  this.data = data;  this.left = null;  this.right = null;  } } // function to check if given  // node is a leaf node or node function isLeaf(node) {    // For a node to be a leaf node it should  // satisfy the following two conditions:  // 1. Node's left's right pointer should be   // current node.  // 2. Node's right's left pointer should be   // current node.    // If one condition is met it is guaranteed  // that the other condition is also true.  return node.left && node.left.right === node  && node.right && node.right.left === node; } // Compute the height of a tree  function findTreeHeight(node) {    // if node is NULL return -1.  if (node === null)  return -1;  // if node is a leaf node return 0  if (isLeaf(node))  return 0;  // compute the depth of each subtree and take maximum  return 1 + Math.max(findTreeHeight(node.left) findTreeHeight(node.right)); } 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.left.left.left = new Node(6); // Given tree contains 3 leaf nodes const l1 = root.left.left.left; const l2 = root.left.right; const l3 = root.right; // create circular doubly linked list out of // leaf nodes of the tree // set next pointer of linked list l1.right = l2; l2.right = l3; l3.right = l1; // set prev pointer of linked list l3.left = l2; l2.left = l1; l1.left = l3; console.log(findTreeHeight(root));

Uitvoer 
3

Tijdcomplexiteit: O(n) waar N is het aantal knooppunten.
Hulpruimte: Oh)