Second Largest element in n-ary tree

Given an n-ary tree containing positive node values, the task is to find the node with the second largest value in the given n-ary tree. If there is no second largest node return -1.
Note: An n-ary tree is a tree where each node can have zero or more children nodes. Unlike a binary tree, which has at most two children per node (left and right), the n-ary tree allows for multiple branches or children for each node.

Examples

Input:

Output: 77
Explanation: The node with the second largest value in the tree is 77.
Input:

Output: 86
Explanation: The node with the second largest value in the tree is 86.

A simple solution is to traverse the array twice. In the first traversal find the maximum value node. In the second traversal find the greatest element node less than the element obtained in first traversal. The time complexity of this solution is O(n).

Approach:

The idea is to recursively traverse the tree while maintaining two variables, largest and second largest. These variables are updated as needed during the traversal, so by the end, we have both the largest and second largest values. Since only the second largest is required, we return that value.

Below is the complete algorithm for doing this:

Initialize two variables, say first and second to -1 initially.
Start traversing the tree:
- If the current node data say root->data is greater than first then update first and second as, second = first and first = root-> data
- If the current node data is in between first and second, then update second to store the value of current node as second = root->data
Return the node stored in second.

Below is the implementation of the above approach:

C++

// C++ Code to find the second largest node value
// in the given N-ary tree using recursion
#include <bits/stdc++.h>
using namespace std;

class Node {
public:
    int data;
    vector<Node*> children;

    Node(int val) {
        data = val;
    }
};

// Recursive function to find the largest
// and second largest values
void findLargestAndSecondLargest(Node* root, 
                            int& first, int& second) {

    // If the tree is empty, return
    if (!root) {
        return;
    }

    // Update first and second largest values
    if (root->data > first) {
        second = first;
        first = root->data;
    } 
    else if (root->data > second && root->data < first) {
        second = root->data;
    }

    // Recur for all children
    for (auto child : root->children) {
        findLargestAndSecondLargest(child, first, second);
    }
}

// Function to find the second largest node value
int findSecondLargestNode(Node* root) {

    int first = -1;
    int second = -1;

    // Find the largest and second largest values
    findLargestAndSecondLargest(root, first, second);

    // Return the second largest value, or -1 if not found
    return second;
}

int main() {

    // Representation of given N-ary tree
    //         11
    //       /  |  \
    //     21   29  90
    //    /    /  \   \
    //   18   10  12  77
  
    Node* root = new Node(11);
    root->children.push_back(new Node(21));
    root->children.push_back(new Node(29));
    root->children.push_back(new Node(90));
    root->children[0]->children.push_back(new Node(18));
    root->children[1]->children.push_back(new Node(10));
    root->children[1]->children.push_back(new Node(12));
    root->children[2]->children.push_back(new Node(77));

    cout << findSecondLargestNode(root);

    return 0;
}

Java

// Java Code to find the second largest node value
// in the given N-ary tree using recursion
import java.util.*;

class Node {
    public int data;
    public List<Node> children;

    public Node(int val) {
        data = val;
        children = new ArrayList<>();
    }
}

// Recursive function to find the largest
// and second largest values
class GfG {

    static void findLargestAndSecondLargest(Node root, 
                             int[] first, int[] second) {

        // If the tree is empty, return
        if (root == null) {
            return;
        }

        // Update first and second largest values
        if (root.data > first[0]) {
            second[0] = first[0];
            first[0] = root.data;
        } 
        else if (root.data > second[0]
                          && root.data < first[0]) {
          
            second[0] = root.data;
        }

        // Recur for all children
        for (Node child : root.children) {
            findLargestAndSecondLargest(child, first, second);
        }
    }

    // Function to find the second largest node value
    static int findSecondLargestNode(Node root) {

        int[] first = {-1};
        int[] second = {-1};

        // Find the largest and second largest values
        findLargestAndSecondLargest(root, first, second);

        // Return the second largest value, 
      	// or -1 if not found
        return second[0];
    }

    public static void main(String[] args) {

        // Representation of the given N-ary tree
        //         11
        //       /  |  \
        //     21   29  90
        //    /    /  \   \
        //   18   10  12  77
        Node root = new Node(11);
        root.children.add(new Node(21));
        root.children.add(new Node(29));
        root.children.add(new Node(90));
        root.children.get(0).children.add(new Node(18));
        root.children.get(1).children.add(new Node(10));
        root.children.get(1).children.add(new Node(12));
        root.children.get(2).children.add(new Node(77));

        System.out.println(findSecondLargestNode(root));
    }
}

Python

# Python Code to find the second largest node value
# in the given N-ary tree using recursion
class Node:
    def __init__(self, val):
        self.data = val
        self.children = []

# Recursive function to find the largest
# and second largest values
def find_largest_and_second_largest(root, first, second):

    # If the tree is empty, return
    if not root:
        return

    # Update first and second largest values
    if root.data > first[0]:
        second[0] = first[0]
        first[0] = root.data
    elif root.data > second[0] and root.data < first[0]:
        second[0] = root.data

    # Recur for all children
    for child in root.children:
        find_largest_and_second_largest(child, first, second)

# Function to find the second largest node value
def find_second_largest_node(root):

    first = [-1]
    second = [-1]

    # Find the largest and second largest values
    find_largest_and_second_largest(root, first, second)

    # Return the second largest value, or -1 if not found
    return second[0]

if __name__ == "__main__":

  # Representation of given N-ary tree
  #         11
  #       /  |  \
  #     21   29  90
  #    /    /  \   \
  #   18   10  12  77
  root = Node(11)
  root.children.append(Node(21))
  root.children.append(Node(29))
  root.children.append(Node(90))
  root.children[0].children.append(Node(18))
  root.children[1].children.append(Node(10))
  root.children[1].children.append(Node(12))
  root.children[2].children.append(Node(77))

  print(find_second_largest_node(root))

// C# Code to find the second largest node value
// in the given N-ary tree using recursion
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 find the largest
// and second largest values
class GfG {

    static void findLargestAndSecondLargest(Node root, 
                             ref int first, ref int second) {

        // If the tree is empty, return
        if (root == null) {
            return;
        }

        // Update first and second largest values
        if (root.data > first) {
            second = first;
            first = root.data;
        } 
        else if (root.data > second && root.data < first) {
            second = root.data;
        }

        // Recur for all children
        foreach (Node child in root.children) {
            findLargestAndSecondLargest(child,
                                ref first, ref second);
        }
    }

    // Function to find the second largest node value
 	static int findSecondLargestNode(Node root) {

        int first = -1;
        int second = -1;

        // Find the largest and second largest values
        findLargestAndSecondLargest(root,
                                 ref first, ref second);

        // Return the second largest value,
        // or -1 if not found
        return second;
    }

    static void Main() {

        // Representation of given N-ary tree
        //         11
        //       /  |  \
        //     21   29  90
        //    /    /  \   \
        //   18   10  12  77
        Node root = new Node(11);
        root.children.Add(new Node(21));
        root.children.Add(new Node(29));
        root.children.Add(new Node(90));
        root.children[0].children.Add(new Node(18));
        root.children[1].children.Add(new Node(10));
        root.children[1].children.Add(new Node(12));
        root.children[2].children.Add(new Node(77));

        Console.WriteLine(findSecondLargestNode(root));
    }
}

JavaScript

// JavaScript Code to find the second largest node value
// in the given N-ary tree using recursion
class Node {
    constructor(val) {
        this.data = val;
        this.children = [];
    }
}

// Recursive function to find the largest
// and second largest values
function findLargestAndSecondLargest(root, first, second) {

    // If the tree is empty, return
    if (!root) {
        return;
    }

    // Update first and second largest values
    if (root.data > first[0]) {
        second[0] = first[0];
        first[0] = root.data;
    } 
    else if (root.data > second[0] && root.data < first[0]) {
        second[0] = root.data;
    }

    // Recur for all children
    for (let child of root.children) {
        findLargestAndSecondLargest(child, first, second);
    }
}

// Function to find the second largest node value
function findSecondLargestNode(root) {

    let first = [-1];
    let second = [-1];

    // Find the largest and second largest values
    findLargestAndSecondLargest(root, first, second);

    // Return the second largest value, or -1 if not found
    return second[0];
}

// Representation of given N-ary tree
//         11
//       /  |  \
//     21   29  90
//    /    /  \   \
//   18   10  12  77
const root = new Node(11);
root.children.push(new Node(21));
root.children.push(new Node(29));
root.children.push(new Node(90));
root.children[0].children.push(new Node(18));
root.children[1].children.push(new Node(10));
root.children[1].children.push(new Node(12));
root.children[2].children.push(new Node(77));

console.log(findSecondLargestNode(root));

Output

Time Complexity: O(n), where n is the number of nodes, as each node is visited once during the traversal.
Auxiliary Space: O(h), where h is the height of the tree due to the recursion stack, with worst-case space being O(n) if the tree is skewed.

Second Largest element in n-ary tree

Explore