የሁለትዮሽ ዛፍ ከፍተኛው ጥልቀት

የችግር ደረጃ ቀላል
ውስጥ በተደጋጋሚ ተጠየቀ አማዞን ካዴንስ ህንድ ኩፖንዱኒያ ፋርስት ፍሪጅ ቻርጅ MakeMyTrip የሞኖታይፕ መፍትሔዎች Snapdeal Synopsys ተራዳታ VMware ቮሆ
ጥልቀት የመጀመሪያ ፍለጋ ዛፍ የዛፍ ተሻጋሪ

ዝርዝር ሁኔታ

የችግሩ መግለጫ

“ከፍተኛ ጥልቀት ያለው የሁለትዮሽ ዛፍ” ችግር የሁለትዮሽ ዛፍ መረጃ መዋቅር ይሰጥዎታል ይላል። የተሰጠውን ከፍተኛውን ጥልቀት ያትሙ ሁለትዮሽ ዛፍ.

ለምሳሌ

ግቤት

`2`

ማብራሪያ ለተሰጠው ዛፍ ከፍተኛው ጥልቀት 2. ነው ምክንያቱም በግራና በቀኝ ንዑስ ዛፍ ውስጥ ከሥሩ በታች አንድ ንጥረ ነገር (ማለትም ከሥሩ ደረጃ የበለጠ ጥልቀት = 1) ብቻ ስላለ ፡፡

ግቤት

`3`

ማብራሪያ-በቀኝ ንዑስ ዛፍ ውስጥ በደረጃ = 3 ሁለት አካላት አሉ ፡፡ ስለዚህ ከፍተኛ ጥልቀት = 3.

ለከፍተኛው ጥልቀት ሁለትዮሽ ዛፍ አልጎሪዝም

```1. Initialize a binary tree data structure.
2. Create a class node with a variable of integer type and the two-node type pointers left and right as it's private members.
3. Create a function newNode to create a new node of the binary tree which accepts a variable of integer type consisting of data as it's a parameter.
4. After that, initialize a new node inside it. Store the integer variable given as a parameter in the data of the node of the binary tree and update the value of it's left and the right pointer is null.
5. Return the newly created node.
6. Similarly, create a function to find the maximum depth of the binary tree which accepts a node pointer as it's a parameter.
7. Check if the node is equal to null, return 0.
8. Else create a variable left of integer type representing the depth of the left subtree. Make a recursive call to the function itself with the left of the node as it's a parameter and store the result returned in the variable left.
9. Similarly, create a variable right of integer type representing the depth of the right subtree. Make a recursive call to the function itself with the right of the node as it's a parameter and store the result returned in the variable right.
10. After that, check if the depth of the left subtree is greater than the depth of the right subtree return the depth of the left subtree + 1.
11. Else return the variable right i.e. the depth of the right subtree + 1.```

ውስጥ አንድ የሁለትዮሽ ዛፍ መረጃ መዋቅር፣ እኛ ግራ እና ቀኝ አንጓዎች አሉን ፣ ከዚያ እሱ ራሱ ግራ እና ቀኝ ቦዶች አሉት። ስለዚህ ፣ እንደ ዛፍ የመሰለ የመረጃ መዋቅር። በሁለትዮሽ ዛፍ ውስጥ ንዑስ ቁጥሮችን ለመሥራት አንጓዎች ተገናኝተዋል ፡፡ ስለዚህ ፣ ለ ‹ሁለትዮሽ› ዛፍ መረጃ መዋቅር የተወሰኑ ቃላቶችን እንገልፃለን ፡፡ እና ከመካከላቸው አንዱ ከፍተኛው ጥልቀት ነው ፣ እሱም የዛፉ ከፍተኛ ቁመት ከሥሩ እስከ ቅጠል ያለው ርቀት ተብሎ ይገለጻል ፡፡ ቅጠል ግራ ወይም ቀኝ መስቀለኛ መንገድ ከሌለው መስቀለኛ ክፍል በስተቀር ሌላ ምንም ነገር አይደለም ፡፡

ከፍተኛውን ጥልቀት ለማግኘት የግራ እና የቀኝ ንዑስ ጥልቀት እንሰላለን ፡፡ የአሁኑ ዛፍ ጥልቀት ከከፍተኛው የግራ እና የቀኝ ንዑስ ዛፍ +1 ጋር እኩል ነው። ስለሆነም የግራ እና የቀኝ ንዑስ ንጣፎችን ጥልቀት ለማግኘት እንደገና የማገናዘብ ዘዴን እንጠቀማለን ፡፡ እኛ እንደገና መመለሻን እየተጠቀምን ስለሆነ የተወሰኑ መሰረታዊ ጉዳዮች ሊኖሩን ይገባል ፡፡ እዚህ የመሠረቱ ጉዳይ ቅጠል በሆነ መስቀለኛ ክፍል ላይ ከሆንን ነው ፡፡ የቅጠል መስቀለኛ መንገድ ርዝመት = 1 አለው ፡፡

ኮድ

የሁለትዮሽ ዛፍ ከፍተኛ ጥልቀት ለማግኘት የ C ++ ፕሮግራም

```#include <bits/stdc++.h>
using namespace std;

class node{
public:
int data;
node* left;
node* right;
};

int maxDepth(node* node){
if(node == NULL)
return 0;
else{
int left = maxDepth(node->left);
int right = maxDepth(node->right);

if(left > right)
return(left + 1);
else return(right + 1);
}
}

node* newNode(int data){
node* Node = new node();
Node->data = data;
Node->left = NULL;
Node->right = NULL;

return(Node);
}

int main(){
node *root = newNode(2);

root->left = newNode(3);
root->right = newNode(8);
root->left->left = newNode(6);
root->left->right = newNode(9);

cout<<maxDepth(root);
return 0;
}```
`3`

ከፍተኛ ጥልቀት ያለው የሁለትዮሽ ዛፍ ለማግኘት የጃቫ ፕሮግራም

```class Node{
int data;
Node left, right;

Node(int item){
data = item;
left = right = null;
}
}

class BinaryTree{
Node root;

int maxDepth(Node node){
if(node == null)
return 0;
else{
int left = maxDepth(node.left);
int right = maxDepth(node.right);

if(left > right)
return (left + 1);
else
return (right + 1);
}
}

public static void main(String[] args){
BinaryTree tree = new BinaryTree();

tree.root = new Node(2);
tree.root.left = new Node(3);
tree.root.right = new Node(8);
tree.root.left.left = new Node(6);
tree.root.left.right = new Node(9);

System.out.println(tree.maxDepth(tree.root));
}
}```
`3`

ውስብስብነት ትንተና

የጊዜ ውስብስብነት

ኦ (ኤን) በተሰጠው ሁለትዮሽ ዛፍ ውስጥ የገባ የመረጃ አንጓዎች ቁጥር የት ነው?

የቦታ ውስብስብነት

ኦ (1) ምክንያቱም እኛ የማያቋርጥ ተጨማሪ ቦታ እንጠቀም ነበር ፡፡

ማጣቀሻዎች