📌  相关文章
📜  在二叉树中找到最深的节点

📅  最后修改于: 2022-05-13 01:57:19.721000             🧑  作者: Mango

在二叉树中找到最深的节点

给定一棵二叉树,找出其中最深的节点。
例子:

Input : Root of below tree
            1
          /   \
         2      3
        / \    / \ 
       4   5  6   7
                   \
                    8
Output : 8

Input : Root of below tree
            1
          /   \
         2      3
               / 
              6  
Output : 6

方法1:想法是对给定的二叉树进行中序遍历。在进行中序遍历时,我们也传递了当前节点的级别。我们跟踪迄今为止看到的最高级别和迄今为止看到的最深节点的值。

C++
// A C++ program to find value of the deepest node
// in a given binary tree
#include 
using namespace std;
 
// A tree node
struct Node
{
    int data;
    struct Node *left, *right;
};
 
// Utility function to create a new node
Node *newNode(int data)
{
    Node *temp = new Node;
    temp->data = data;
    temp->left = temp->right = NULL;
    return temp;
}
 
// maxLevel : keeps track of maximum level seen so far.
// res :  Value of deepest node so far.
// level : Level of root
void find(Node *root, int level, int &maxLevel, int &res)
{
    if (root != NULL)
    {
        find(root->left, ++level, maxLevel, res);
 
        // Update level and rescue
        if (level > maxLevel)
        {
            res = root->data;
            maxLevel = level;
        }
 
        find(root->right, level, maxLevel, res);
    }
}
 
// Returns value of deepest node
int deepestNode(Node *root)
{
    // Initialize result and max level
    int res = -1;
    int maxLevel = -1;
 
    // Updates value "res" and "maxLevel"
    // Note that res and maxLen are passed
    // by reference.
    find(root, 0, maxLevel, res);
    return res;
}
 
// Driver program
int main()
{
    Node* root = newNode(1);
    root->left = newNode(2);
    root->right = newNode(3);
    root->left->left = newNode(4);
    root->right->left = newNode(5);
    root->right->right = newNode(6);
    root->right->left->right = newNode(7);
    root->right->right->right = newNode(8);
    root->right->left->right->left = newNode(9);
    cout << deepestNode(root);
    return 0;
}


Java
// Java program to find value of the deepest node
// in a given binary tree
class GFG
{
 
    // A tree node
    static class Node
    {
 
        int data;
        Node left, right;
 
        Node(int key)
        {
            data = key;
            left = null;
            right = null;
        }
    }
    static int maxLevel = -1;
    static int res = -1;
 
    // maxLevel : keeps track of maximum level seen so far.
    // res : Value of deepest node so far.
    // level : Level of root
    static void find(Node root, int level)
    {
        if (root != null)
        {
            find(root.left, ++level);
 
            // Update level and rescue
            if (level > maxLevel)
            {
                res = root.data;
                maxLevel = level;
            }
 
            find(root.right, level);
        }
    }
 
    // Returns value of deepest node
    static int deepestNode(Node root)
    {
        // Initialize result and max level
        /* int res = -1;
        int maxLevel = -1; */
 
        // Updates value "res" and "maxLevel"
        // Note that res and maxLen are passed
        // by reference.
        find(root, 0);
        return res;
    }
 
    // Driver code
    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.right.left = new Node(5);
        root.right.right = new Node(6);
        root.right.left.right = new Node(7);
        root.right.right.right = new Node(8);
        root.right.left.right.left = new Node(9);
        System.out.println(deepestNode(root));
    }
}
 
// This code is contributed by Princi Singh


Python3
"""Python3 program to find value of the
deepest node in a given binary tree"""
 
# A Binary Tree Node
# Utility function to create a
# new tree node
class newNode:
 
    # Constructor to create a newNode
    def __init__(self, data):
        self.data= data
        self.left = None
        self.right = None
        self.visited = False
 
# maxLevel : keeps track of maximum
# level seen so far.
# res : Value of deepest node so far.
# level : Level of root
def find(root, level, maxLevel, res):
 
    if (root != None):
        level += 1
        find(root.left, level, maxLevel, res)
 
        # Update level and rescue
        if (level > maxLevel[0]):
         
            res[0] = root.data
            maxLevel[0] = level
         
        find(root.right, level, maxLevel, res)
         
# Returns value of deepest node
def deepestNode(root) :
 
    # Initialize result and max level
    res = [-1]
    maxLevel = [-1]
 
    # Updates value "res" and "maxLevel"
    # Note that res and maxLen are passed
    # by reference.
    find(root, 0, maxLevel, res)
    return res[0]
                         
# Driver Code
if __name__ == '__main__':
    root = newNode(1)
    root.left = newNode(2)
    root.right = newNode(3)
    root.left.left = newNode(4)
    root.right.left = newNode(5)
    root.right.right = newNode(6)
    root.right.left.right = newNode(7)
    root.right.right.right = newNode(8)
    root.right.left.right.left = newNode(9)
    print(deepestNode(root))
 
# This code is contributed by
# SHUBHAMSINGH10


C#
// C# program to find value of the deepest node
// in a given binary tree
using System;
     
class GFG
{
 
    // A tree node
    public class Node
    {
 
        public int data;
        public Node left, right;
 
        public Node(int key)
        {
            data = key;
            left = null;
            right = null;
        }
    }
    static int maxLevel = -1;
    static int res = -1;
 
    // maxLevel : keeps track of maximum level seen so far.
    // res : Value of deepest node so far.
    // level : Level of root
    static void find(Node root, int level)
    {
        if (root != null)
        {
            find(root.left, ++level);
 
            // Update level and rescue
            if (level > maxLevel)
            {
                res = root.data;
                maxLevel = level;
            }
 
            find(root.right, level);
        }
    }
 
    // Returns value of deepest node
    static int deepestNode(Node root)
    {
        // Initialize result and max level
        /* int res = -1;
        int maxLevel = -1; */
 
        // Updates value "res" and "maxLevel"
        // Note that res and maxLen are passed
        // by reference.
        find(root, 0);
        return res;
    }
 
    // Driver code
    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.right.left = new Node(5);
        root.right.right = new Node(6);
        root.right.left.right = new Node(7);
        root.right.right.right = new Node(8);
        root.right.left.right.left = new Node(9);
        Console.WriteLine(deepestNode(root));
    }
}
 
// This code is contributed by 29AjayKumar


Javascript


C++
// A C++ program to find value of the
// deepest node in a given binary tree
#include 
using namespace std;
 
// A tree node with constructor
class Node
{
public:
    int data;
    Node *left, *right;
     
    // constructor   
    Node(int key)
    {
        data = key;
        left = NULL;
        right = NULL;
    }
};
 
// Utility function to find height
// of a tree, rooted at 'root'.
int height(Node* root)
{
  if(!root) return 0;
   
  int leftHt = height(root->left);
  int rightHt = height(root->right);
   
  return max(leftHt, rightHt) + 1;
}
 
// levels : current Level
// Utility function to print all
// nodes at a given level.
void deepestNode(Node* root, int levels)
{
    if(!root) return;
     
    if(levels == 1)
    cout << root->data;
     
    else if(levels > 1)
    {
        deepestNode(root->left, levels - 1);
        deepestNode(root->right, levels - 1);
    }
}
 
// Driver program
int main()
{
    Node* root = new Node(1);
    root->left = new Node(2);
    root->right = new Node(3);
    root->left->left = new Node(4);
    root->right->left = new Node(5);
    root->right->right = new Node(6);
    root->right->left->right = new Node(7);
    root->right->right->right = new Node(8);
    root->right->left->right->left = new Node(9);
     
    // Calculating height of tree
    int levels = height(root);
     
    // Printing the deepest node
    deepestNode(root, levels);
     
    return 0;
}
 
// This code is contributed by decode2207.


Java
// A Java program to find value of the
// deepest node in a given binary tree
class GFG
{
     
// A tree node with constructor
static class Node
{
    int data;
    Node left, right;
     
    // constructor
    Node(int key)
    {
        data = key;
        left = null;
        right = null;
    }
};
 
// Utility function to find height
// of a tree, rooted at 'root'.
static int height(Node root)
{
    if(root == null) return 0;
         
    int leftHt = height(root.left);
    int rightHt = height(root.right);
         
    return Math.max(leftHt, rightHt) + 1;
}
 
// levels : current Level
// Utility function to print all
// nodes at a given level.
static void deepestNode(Node root,
                        int levels)
{
    if(root == null) return;
     
    if(levels == 1)
    System.out.print(root.data + " ");
     
    else if(levels > 1)
    {
        deepestNode(root.left, levels - 1);
        deepestNode(root.right, levels - 1);
    }
}
 
// Driver Codede
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.right.left = new Node(5);
    root.right.right = new Node(6);
    root.right.left.right = new Node(7);
    root.right.right.right = new Node(8);
    root.right.left.right.left = new Node(9);
     
    // Calculating height of tree
    int levels = height(root);
     
    // Printing the deepest node
    deepestNode(root, levels);
}
}
 
// This code is contributed by Arnab Kundu


Python3
# A Python3 program to find value of the
# deepest node in a given binary tree
class new_Node:
    def __init__(self, key):
        self.data = key
        self.left = self.right = None
         
# Utility function to find height
# of a tree, rooted at 'root'.
def height(root):
    if(not root):
        return 0
     
    leftHt = height(root.left)
    rightHt = height(root.right)
     
    return max(leftHt, rightHt) + 1
 
# levels : current Level
# Utility function to print all
# nodes at a given level.
def deepestNode(root, levels):
    if(not root):
        return
     
    if(levels == 1):
        print(root.data)
    elif(levels > 1):
        deepestNode(root.left, levels - 1)
        deepestNode(root.right, levels - 1)
 
# Driver Code
if __name__ == '__main__':
 
    root = new_Node(1)
    root.left = new_Node(2)
    root.right = new_Node(3)
    root.left.left = new_Node(4)
    root.right.left = new_Node(5)
    root.right.right = new_Node(6)
    root.right.left.right = new_Node(7)
    root.right.right.right = new_Node(8)
    root.right.left.right.left = new_Node(9)
     
    # Calculating height of tree
    levels = height(root)
     
    # Printing the deepest node
    deepestNode(root, levels)
 
# This code is contributed by PranchalK


C#
// C# program to find value of the
// deepest node in a given binary tree
using System;
     
class GFG
{
     
// A tree node with constructor
public class Node
{
    public int data;
    public Node left, right;
     
    // constructor
    public Node(int key)
    {
        data = key;
        left = null;
        right = null;
    }
};
 
// Utility function to find height
// of a tree, rooted at 'root'.
static int height(Node root)
{
    if(root == null) return 0;
         
    int leftHt = height(root.left);
    int rightHt = height(root.right);
         
    return Math.Max(leftHt, rightHt) + 1;
}
 
// levels : current Level
// Utility function to print all
// nodes at a given level.
static void deepestNode(Node root,
                        int levels)
{
    if(root == null) return;
     
    if(levels == 1)
    Console.Write(root.data + " ");
     
    else if(levels > 1)
    {
        deepestNode(root.left, levels - 1);
        deepestNode(root.right, levels - 1);
    }
}
 
// Driver Code
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.right.left = new Node(5);
    root.right.right = new Node(6);
    root.right.left.right = new Node(7);
    root.right.right.right = new Node(8);
    root.right.left.right.left = new Node(9);
     
    // Calculating height of tree
    int levels = height(root);
     
    // Printing the deepest node
    deepestNode(root, levels);
}
}
 
/* This code contributed by PrinciRaj1992 */


Javascript


C++
// A C++ program to find value of the
// deepest node in a given binary tree
#include 
using namespace std;
 
// A tree node with constructor
class Node
{
public:
    int data;
    Node *left, *right;
      
    // constructor  
    Node(int key)
    {
        data = key;
        left = NULL;
        right = NULL;
    }
};
 
// Function to return the deepest node
Node* deepestNode(Node* root)
{
    Node* tmp = NULL;
    if (root == NULL)
        return NULL;
 
    // Creating a Queue
    queue q;
    q.push(root);
 
    // Iterates until queue become empty
    while (q.size() > 0)
    {
        tmp = q.front();
        q.pop();
        if (tmp->left != NULL)
            q.push(tmp->left);
        if (tmp->right != NULL)
            q.push(tmp->right);
    }
    return tmp;
}
     
int main()
{
    Node* root = new Node(1);
    root->left = new Node(2);
    root->right = new Node(3);
    root->left->left = new Node(4);
    root->right->left = new Node(5);
    root->right->right = new Node(6);
    root->right->left->right = new Node(7);
    root->right->right->right = new Node(8);
    root->right->left->right->left = new Node(9);
 
    Node* deepNode = deepestNode(root);
    cout << (deepNode->data);
 
    return 0;
}


Java
import java.util.*;
 
// A Java program to find value of the
// deepest node in a given binary tree
 
// A tree node with constructor
public class Node
{
    int data;
    Node left, right;
 
    // constructor
    Node(int key)
    {
        data = key;
        left = null;
        right = null;
    }
};
 
class Gfg
{
   
    // Function to return the deepest node
    public static Node deepestNode(Node root)
    {
        Node tmp = null;
        if (root == null)
            return null;
 
        // Creating a Queue
        Queue q = new LinkedList();
        q.offer(root);
 
        // Iterates until queue become empty
        while (!q.isEmpty())
        {
            tmp = q.poll();
            if (tmp.left != null)
                q.offer(tmp.left);
            if (tmp.right != null)
                q.offer(tmp.right);
        }
        return tmp;
    }
 
    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.right.left = new Node(5);
        root.right.right = new Node(6);
        root.right.left.right = new Node(7);
        root.right.right.right = new Node(8);
        root.right.left.right.left = new Node(9);
 
        Node deepNode = deepestNode(root);
        System.out.println(deepNode.data);
    }
}
 
// Code is contributed by mahi_07


Python3
# A Python3 program to find value of the
# deepest node in a given binary tree by method 3
from collections import deque
 
class new_Node:
    def __init__(self, key):
        self.data = key
        self.left = self.right = None
 
def deepestNode(root):
    if root == None:
        return 0
    q = deque()
    q.append(root)
    node = None
    while len(q) != 0:
        node = q.popleft()
        if node.left is not None:
            q.append(node.left)
        if node.right is not None:
            q.append(node.right)
    return node.data
  
# Driver Code
if __name__ == '__main__':
  
    root = new_Node(1)
    root.left = new_Node(2)
    root.right = new_Node(3)
    root.left.left = new_Node(4)
    root.right.left = new_Node(5)
    root.right.right = new_Node(6)
    root.right.left.right = new_Node(7)
    root.right.right.right = new_Node(8)
    root.right.left.right.left = new_Node(9)
      
    # Calculating height of tree
    levels = deepestNode(root)
      
    # Printing the deepest node
    print(levels)
     
# This code is contributed by Aprajita Chhawi


C#
// A C# program to find value of the
// deepest node in a given binary tree
using System;
using System.Collections.Generic;
 
// A tree node with constructor
public class Node
{
  public
    int data;
  public
    Node left, right;
 
  // constructor
  public
    Node(int key)
  {
    data = key;
    left = null;
    right = null;
  }
};
 
class Gfg
{
 
  // Function to return the deepest node
  public static Node deepestNode(Node root)
  {
    Node tmp = null;
    if (root == null)
      return null;
 
    // Creating a Queue
    Queue q = new Queue();
    q.Enqueue(root);
 
    // Iterates until queue become empty
    while (q.Count != 0)
    {
      tmp = q.Peek();
      q.Dequeue();
      if (tmp.left != null)
        q.Enqueue(tmp.left);
      if (tmp.right != null)
        q.Enqueue(tmp.right);
    }
    return tmp;
  }
 
  // Driver code
  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.right.left = new Node(5);
    root.right.right = new Node(6);
    root.right.left.right = new Node(7);
    root.right.right.right = new Node(8);
    root.right.left.right.left = new Node(9);
 
    Node deepNode = deepestNode(root);
    Console.WriteLine(deepNode.data);
  }
}
 
// This code is contributed by gauravrajput1


Javascript


输出:

9

时间复杂度: O(n)
方法2:这里的想法是找到给定树的高度,然后打印最底层的节点。

C++

// A C++ program to find value of the
// deepest node in a given binary tree
#include 
using namespace std;
 
// A tree node with constructor
class Node
{
public:
    int data;
    Node *left, *right;
     
    // constructor   
    Node(int key)
    {
        data = key;
        left = NULL;
        right = NULL;
    }
};
 
// Utility function to find height
// of a tree, rooted at 'root'.
int height(Node* root)
{
  if(!root) return 0;
   
  int leftHt = height(root->left);
  int rightHt = height(root->right);
   
  return max(leftHt, rightHt) + 1;
}
 
// levels : current Level
// Utility function to print all
// nodes at a given level.
void deepestNode(Node* root, int levels)
{
    if(!root) return;
     
    if(levels == 1)
    cout << root->data;
     
    else if(levels > 1)
    {
        deepestNode(root->left, levels - 1);
        deepestNode(root->right, levels - 1);
    }
}
 
// Driver program
int main()
{
    Node* root = new Node(1);
    root->left = new Node(2);
    root->right = new Node(3);
    root->left->left = new Node(4);
    root->right->left = new Node(5);
    root->right->right = new Node(6);
    root->right->left->right = new Node(7);
    root->right->right->right = new Node(8);
    root->right->left->right->left = new Node(9);
     
    // Calculating height of tree
    int levels = height(root);
     
    // Printing the deepest node
    deepestNode(root, levels);
     
    return 0;
}
 
// This code is contributed by decode2207.

Java

// A Java program to find value of the
// deepest node in a given binary tree
class GFG
{
     
// A tree node with constructor
static class Node
{
    int data;
    Node left, right;
     
    // constructor
    Node(int key)
    {
        data = key;
        left = null;
        right = null;
    }
};
 
// Utility function to find height
// of a tree, rooted at 'root'.
static int height(Node root)
{
    if(root == null) return 0;
         
    int leftHt = height(root.left);
    int rightHt = height(root.right);
         
    return Math.max(leftHt, rightHt) + 1;
}
 
// levels : current Level
// Utility function to print all
// nodes at a given level.
static void deepestNode(Node root,
                        int levels)
{
    if(root == null) return;
     
    if(levels == 1)
    System.out.print(root.data + " ");
     
    else if(levels > 1)
    {
        deepestNode(root.left, levels - 1);
        deepestNode(root.right, levels - 1);
    }
}
 
// Driver Codede
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.right.left = new Node(5);
    root.right.right = new Node(6);
    root.right.left.right = new Node(7);
    root.right.right.right = new Node(8);
    root.right.left.right.left = new Node(9);
     
    // Calculating height of tree
    int levels = height(root);
     
    // Printing the deepest node
    deepestNode(root, levels);
}
}
 
// This code is contributed by Arnab Kundu

Python3

# A Python3 program to find value of the
# deepest node in a given binary tree
class new_Node:
    def __init__(self, key):
        self.data = key
        self.left = self.right = None
         
# Utility function to find height
# of a tree, rooted at 'root'.
def height(root):
    if(not root):
        return 0
     
    leftHt = height(root.left)
    rightHt = height(root.right)
     
    return max(leftHt, rightHt) + 1
 
# levels : current Level
# Utility function to print all
# nodes at a given level.
def deepestNode(root, levels):
    if(not root):
        return
     
    if(levels == 1):
        print(root.data)
    elif(levels > 1):
        deepestNode(root.left, levels - 1)
        deepestNode(root.right, levels - 1)
 
# Driver Code
if __name__ == '__main__':
 
    root = new_Node(1)
    root.left = new_Node(2)
    root.right = new_Node(3)
    root.left.left = new_Node(4)
    root.right.left = new_Node(5)
    root.right.right = new_Node(6)
    root.right.left.right = new_Node(7)
    root.right.right.right = new_Node(8)
    root.right.left.right.left = new_Node(9)
     
    # Calculating height of tree
    levels = height(root)
     
    # Printing the deepest node
    deepestNode(root, levels)
 
# This code is contributed by PranchalK

C#

// C# program to find value of the
// deepest node in a given binary tree
using System;
     
class GFG
{
     
// A tree node with constructor
public class Node
{
    public int data;
    public Node left, right;
     
    // constructor
    public Node(int key)
    {
        data = key;
        left = null;
        right = null;
    }
};
 
// Utility function to find height
// of a tree, rooted at 'root'.
static int height(Node root)
{
    if(root == null) return 0;
         
    int leftHt = height(root.left);
    int rightHt = height(root.right);
         
    return Math.Max(leftHt, rightHt) + 1;
}
 
// levels : current Level
// Utility function to print all
// nodes at a given level.
static void deepestNode(Node root,
                        int levels)
{
    if(root == null) return;
     
    if(levels == 1)
    Console.Write(root.data + " ");
     
    else if(levels > 1)
    {
        deepestNode(root.left, levels - 1);
        deepestNode(root.right, levels - 1);
    }
}
 
// Driver Code
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.right.left = new Node(5);
    root.right.right = new Node(6);
    root.right.left.right = new Node(7);
    root.right.right.right = new Node(8);
    root.right.left.right.left = new Node(9);
     
    // Calculating height of tree
    int levels = height(root);
     
    // Printing the deepest node
    deepestNode(root, levels);
}
}
 
/* This code contributed by PrinciRaj1992 */

Javascript


输出:

9

时间复杂度: O(n)
感谢Parth Patekar提出上述方法。

方法3 :从队列中按级别顺序处理的最后一个节点是二叉树中最深的节点。

C++

// A C++ program to find value of the
// deepest node in a given binary tree
#include 
using namespace std;
 
// A tree node with constructor
class Node
{
public:
    int data;
    Node *left, *right;
      
    // constructor  
    Node(int key)
    {
        data = key;
        left = NULL;
        right = NULL;
    }
};
 
// Function to return the deepest node
Node* deepestNode(Node* root)
{
    Node* tmp = NULL;
    if (root == NULL)
        return NULL;
 
    // Creating a Queue
    queue q;
    q.push(root);
 
    // Iterates until queue become empty
    while (q.size() > 0)
    {
        tmp = q.front();
        q.pop();
        if (tmp->left != NULL)
            q.push(tmp->left);
        if (tmp->right != NULL)
            q.push(tmp->right);
    }
    return tmp;
}
     
int main()
{
    Node* root = new Node(1);
    root->left = new Node(2);
    root->right = new Node(3);
    root->left->left = new Node(4);
    root->right->left = new Node(5);
    root->right->right = new Node(6);
    root->right->left->right = new Node(7);
    root->right->right->right = new Node(8);
    root->right->left->right->left = new Node(9);
 
    Node* deepNode = deepestNode(root);
    cout << (deepNode->data);
 
    return 0;
}

Java

import java.util.*;
 
// A Java program to find value of the
// deepest node in a given binary tree
 
// A tree node with constructor
public class Node
{
    int data;
    Node left, right;
 
    // constructor
    Node(int key)
    {
        data = key;
        left = null;
        right = null;
    }
};
 
class Gfg
{
   
    // Function to return the deepest node
    public static Node deepestNode(Node root)
    {
        Node tmp = null;
        if (root == null)
            return null;
 
        // Creating a Queue
        Queue q = new LinkedList();
        q.offer(root);
 
        // Iterates until queue become empty
        while (!q.isEmpty())
        {
            tmp = q.poll();
            if (tmp.left != null)
                q.offer(tmp.left);
            if (tmp.right != null)
                q.offer(tmp.right);
        }
        return tmp;
    }
 
    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.right.left = new Node(5);
        root.right.right = new Node(6);
        root.right.left.right = new Node(7);
        root.right.right.right = new Node(8);
        root.right.left.right.left = new Node(9);
 
        Node deepNode = deepestNode(root);
        System.out.println(deepNode.data);
    }
}
 
// Code is contributed by mahi_07

Python3

# A Python3 program to find value of the
# deepest node in a given binary tree by method 3
from collections import deque
 
class new_Node:
    def __init__(self, key):
        self.data = key
        self.left = self.right = None
 
def deepestNode(root):
    if root == None:
        return 0
    q = deque()
    q.append(root)
    node = None
    while len(q) != 0:
        node = q.popleft()
        if node.left is not None:
            q.append(node.left)
        if node.right is not None:
            q.append(node.right)
    return node.data
  
# Driver Code
if __name__ == '__main__':
  
    root = new_Node(1)
    root.left = new_Node(2)
    root.right = new_Node(3)
    root.left.left = new_Node(4)
    root.right.left = new_Node(5)
    root.right.right = new_Node(6)
    root.right.left.right = new_Node(7)
    root.right.right.right = new_Node(8)
    root.right.left.right.left = new_Node(9)
      
    # Calculating height of tree
    levels = deepestNode(root)
      
    # Printing the deepest node
    print(levels)
     
# This code is contributed by Aprajita Chhawi

C#

// A C# program to find value of the
// deepest node in a given binary tree
using System;
using System.Collections.Generic;
 
// A tree node with constructor
public class Node
{
  public
    int data;
  public
    Node left, right;
 
  // constructor
  public
    Node(int key)
  {
    data = key;
    left = null;
    right = null;
  }
};
 
class Gfg
{
 
  // Function to return the deepest node
  public static Node deepestNode(Node root)
  {
    Node tmp = null;
    if (root == null)
      return null;
 
    // Creating a Queue
    Queue q = new Queue();
    q.Enqueue(root);
 
    // Iterates until queue become empty
    while (q.Count != 0)
    {
      tmp = q.Peek();
      q.Dequeue();
      if (tmp.left != null)
        q.Enqueue(tmp.left);
      if (tmp.right != null)
        q.Enqueue(tmp.right);
    }
    return tmp;
  }
 
  // Driver code
  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.right.left = new Node(5);
    root.right.right = new Node(6);
    root.right.left.right = new Node(7);
    root.right.right.right = new Node(8);
    root.right.left.right.left = new Node(9);
 
    Node deepNode = deepestNode(root);
    Console.WriteLine(deepNode.data);
  }
}
 
// This code is contributed by gauravrajput1

Javascript



输出
9

时间复杂度: O(n)

空间复杂度: O(n)

?list=PLqM7alHXFySHCXD7r1J0ky9Zg_GBB1dbk