问. 查找二叉树中最大元素的程序。

2025年3月17日 | 阅读 7 分钟

说明

在此程序中，我们将找出给定二叉树中的最大节点。我们首先定义变量 max，它将保存根的数据。然后，我们遍历左子树以找到最大的节点。将其与 max 进行比较，并将两者中的最大值存储在变量 max 中。然后，我们遍历右子树以找到最大的节点，并将其与 max 进行比较。最后，max 将拥有最大的节点。

Program to find the largest element in a Binary Tree

上面的图代表一棵二叉树。最初，max 将包含 15。递归遍历左子树。

max = 15, leftMax = 20 => (20 > 15) then max = 20
max = 20, leftMax = 74 => (74 > 20) then max = 74

递归遍历右子树。

递归遍历 35 的左子树

递归遍历 35 的右子树

因此，上述二叉树中的最大节点是 74。

算法

定义类 Node，它具有三个属性：data、left 和 right。在此，left 表示节点的左子节点，right 表示节点的右子节点。
将节点的 data 部分分配给适当的值，并将 left 和 right 分配为 null。
定义另一个类，该类有一个 root 属性。
1. Root 表示树的根节点，它被初始化为 null。
2. largestElement() 将找出二叉树中的最大节点
  1. 它检查根是否为空，这意味着树是空的。
  2. 如果树不为空，则定义一个变量 max，它将存储 temp 的数据。
  3. 通过递归调用 largestElement() 来找出左子树中的最大节点。将该值存储在 leftMax 中。将 max 的值与 leftMax 进行比较，并将两者中的最大值存储在 max 中。
  4. 通过递归调用 largestElement() 来找出右子树中的最大节点。将该值存储在 rightMax 中。将 max 的值与 rightMax 进行比较，并将两者中的最大值存储在 max 中。
  5. 最后，max 将持有二叉树中的最大节点。

解决方案

Python

#Represent a node of binary tree
class Node:
    def __init__(self,data):
        #Assign data to the new node, set left and right children to None
        self.data = data;
        self.left = None;
        self.right = None;
 
class LargestNode:
    def __init__(self):
        #Represent the root of binary tree
        self.root = None;
        
    #largestElement() will find out the largest node in the binary tree
    def largestElement(self, temp):
        #Check whether tree is empty
        if(self.root == None):
            print("Tree is empty");
            return 0;
            
        else:    
            #Variable maximum will store temp's data
            maximum = temp.data;
            
            #It will find largest element in left subtree
            if(temp.left != None):
                leftMax = self.largestElement(temp.left);
                #Compare variable maximum with leftMax and store greater value into maximum
                maximum = max(maximum, leftMax);
            
            #It will find largest element in right subtree
            if(temp.right != None):
                rightMax = self.largestElement(temp.right);
                #Compare variable maximum with rightMax and store greater value into maximum
                maximum = max(maximum, rightMax);
            
            return maximum;
 
bt = LargestNode();
#Add nodes to the binary tree
bt.root = Node(15);
bt.root.left = Node(20);
bt.root.right = Node(35);
bt.root.left.left = Node(74);
bt.root.right.left = Node(55);
bt.root.right.right = Node(6);
 
#Display largest node in the binary tree
print("Largest element in the binary tree: " + str(bt.largestElement(bt.root)));

输出

Largest element in the binary tree: 74

C

#include <stdio.h>
#include <stdbool.h>
#include <stdlib.h>
 
//Represent a node of binary tree
struct node{
    int data;
    struct node *left;
    struct node *right;
};
 
//Represent the root of binary tree
struct node *root = NULL;
 
//createNode() will create a new node
struct node* createNode(int data){
    //Create a new node
    struct node *newNode = (struct node*)malloc(sizeof(struct node));
    //Assign data to newNode, set left and right children to NULL
    newNode->data = data;
    newNode->left = NULL;
    newNode->right = NULL;
    
    return newNode;
}
 
//largestElement() will find out the largest node in the binary tree
int largestElement(struct node *temp){
    //Check whether tree is empty
    if(root == NULL) {
        printf("Tree is empty\n");
        return 0;
    }
    else{
        int leftMax, rightMax;
        //Max will store temp's data
        int max = temp->data;
        //It will find largest element in left subtree
        if(temp->left != NULL){
            leftMax = largestElement(temp->left);
            //Compare max with leftMax and store greater value into max
            max = (max > leftMax) ? max : leftMax;
        }
      
        //It will find largest element in right subtree
        if(temp->right != NULL){
          rightMax = largestElement(temp->right);
          //Compare max with rightMax and store greater value into max
          max = (max > rightMax) ? max : rightMax;
        }
    return max;
    }
}
 
int main()
{
    //Add nodes to the binary tree
    root = createNode(15);
    root->left = createNode(20);
    root->right = createNode(35);
    root->left->left = createNode(74);
    root->right->left = createNode(55);
    root->right->right = createNode(6);
        
    //Display largest node in the binary tree
    printf("Largest element in the binary tree: %d", largestElement(root));
    return 0;
}

输出

Largest element in the binary tree: 74

JAVA

public class LargestNode {
    //Represent the node of binary tree
    public static class Node{
        int data;
        Node left;
        Node right;
        
        public Node(int data){
            //Assign data to the new node, set left and right children to null
            this.data = data;
            this.left = null;
            this.right = null;
        }
     }
      
      //Represent the root of binary tree
      public Node root;
      
      public LargestNode(){
        root = null;
      }
      
      //largestElement() will find out the largest node in the binary tree
      public int largestElement(Node temp){
          //Check whether tree is empty
           if(root == null) {
               System.out.println("Tree is empty");
               return 0;
            }
           else{
               int leftMax, rightMax;
               //Max will store temp's data
               int max = temp.data;
                
               //It will find largest element in left subtree
               if(temp.left != null){
                   leftMax = largestElement(temp.left);
                   //Compare max with leftMax and store greater value into max
                   max = Math.max(max, leftMax);
                }
                
                //It will find largest element in right subtree
                if(temp.right != null){
                    rightMax = largestElement(temp.right);
                    //Compare max with rightMax and store greater value into max
                    max = Math.max(max, rightMax);
                }
                return max;
           }
      }
      
      public static void main(String[] args) {
        
        LargestNode bt = new LargestNode();
        //Add nodes to the binary tree
        bt.root = new Node(15);
        bt.root.left = new Node(20);
        bt.root.right = new Node(35);
        bt.root.left.left = new Node(74);
        bt.root.right.left = new Node(55);
        bt.root.right.right = new Node(6);
        
        //Display largest node in the binary tree
        System.out.println("Largest element in the binary tree: " + bt.largestElement(bt.root));
      }
}

输出

Largest element in the binary tree: 74

C#

using System; 
namespace Tree 
{                     
    public class Program
    {
        //Represent a node of binary tree
        public class Node<T>{
            public T data;
            public Node<T> left;
            public Node<T> right;
            
            public Node(T data) {
                //Assign data to the new node, set left and right children to null
                this.data = data;
                this.left = null;
                this.right = null;
            }
        }
        
        public class LargestNode<T> where T : IComparable<T>{
            //Represent the root of binary tree
            public Node<T> root;
 
            public LargestNode(){
                root = null;
            }
            
        //largestElement() will find out the largest node in the binary tree
        public T largestElement(Node<T> temp){
            //Check whether tree is empty
            if(root == null) {
               Console.WriteLine("Tree is empty");
               return default(T);
            }
            else{
                T leftMax, rightMax;
                //Max will store temp's data
                T max = temp.data;
 
                //It will find largest element in left subtree
                if(temp.left != null){
                  leftMax = largestElement(temp.left);
                  //Compare max with leftMax and store greater value into max
                  max = (max.CompareTo(leftMax) < 0) ? leftMax : max;
                }
 
                //It will find largest element in right subtree
                if(temp.right != null){
                  rightMax = largestElement(temp.right);
                //Compare max with rightMax and store greater value into max
                  max = (max.CompareTo(rightMax) < 0) ? rightMax : max;
                }
                return max;
            }
        }
    }
        
    public static void Main()
    {
        LargestNode<int> bt = new LargestNode<int>();
        //Add nodes to the binary tree
        bt.root = new Node<int>(15);
        bt.root.left = new Node<int>(20);
        bt.root.right = new Node<int>(35);
        bt.root.left.left = new Node<int>(74);
        bt.root.right.left = new Node<int>(55);
        bt.root.right.right = new Node<int>(6);
 
        //Display largest node in the binary tree
        Console.WriteLine("Largest element in the binary tree: " + bt.largestElement(bt.root));
        }    
    }
}

输出

Largest element in the binary tree: 74

PHP

<!DOCTYPE html>
<html>
<body>
<?php
//Represent a node of binary tree
class Node{
    public $data;
    public $left;
    public $right;
    
    function __construct($data){
        //Assign data to the new node, set left and right children to NULL
        $this->data = $data;
        $this->left = NULL;
        $this->right = NULL;
    }
}
class LargestNode{
    //Represent the root of binary tree
    public $root;
    function __construct(){
        $this->root = NULL;
    }
    
    //largestElement() will find out the largest node in the binary tree
    function largestElement($temp){
      //Check whether tree is empty
       if($this->root == NULL) {
           print "Tree is empty<br>";
           return 0;
        }
       else{
           //$max will store $temp's data
           $max = $temp->data;
           
           //It will find largest element in left subtree
           if($temp->left != NULL){
               $leftMax = $this->largestElement($temp->left);
               //Compare $max with $leftMax and store greater value into $max
               $max = max($max, $leftMax); 
            }
            
            //It will find largest element in right subtree
            if($temp->right != NULL){
                $rightMax = $this->largestElement($temp->right);
                //Compare $max with $rightMax and store greater value into $max
                $max = max($max, $rightMax);
            }
           return $max;
       }
    } 
}
$bt = new LargestNode();
//Add nodes to the binary tree
$bt->root = new Node(15);
$bt->root->left = new Node(20);
$bt->root->right = new Node(35);
$bt->root->left->left = new Node(74);
$bt->root->right->left = new Node(55);
$bt->root->right->right = new Node(6);
 
//Display largest node in the binary tree
print "Largest element in the binary tree: " . $bt->largestElement($bt->root);      
?>
</body>
</html>

输出

Largest element in the binary tree: 74

下一个主题程序列表

问. 查找二叉树中最大元素的程序。

说明

算法

解决方案

Python

C

JAVA

C#

PHP

联系信息

关注我们

教程

面试题

在线编译器

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

程序

问. 查找二叉树中最大元素的程序。

说明

算法

解决方案

Python

C

JAVA

C#

PHP

相关帖子

在单向链表末尾插入新节点的程序

创建和显示循环链表的程序

编写计算偶数和的程序

在单向链表开头插入新节点的程序

打印给定字符串中最小和最大可能回文单词的程序

在双向链表中间插入新节点的程序

确定两个树是否相同的程序

计算矩形面积的程序

不使用第三个或临时变量交换两个字符串变量的程序

查找字符串中出现次数最多和最少的字符的程序

订阅 Tpoint Tech

联系信息

关注我们

教程

面试题

在线编译器