Immediate Smaller element in an N-ary Tree

Given an element x, task is to find the value of its immediate smaller element. 

Example : 

Input : x = 30 (for above tree)
Output : Immediate smaller element is 25

Explanation : Elements 2, 15, 20 and 25 are smaller than x i.e, 30, but 25 is the immediate smaller element and hence the answer. 

Approach :

• Let res be the resultant node.
• Initialize the resultant Node as NULL.
• For every Node, check if data of root is greater than res, but less than x. if yes, update res.
• Recursively do the same for all nodes of the given Generic Tree.
• Return res, and res->key would be the immediate smaller element.

Below is the implementation of above approach : 

C++

// C++ program to find immediate Smaller
// Element of a given element in a n-ary tree.
#include <bits/stdc++.h>
using namespace std;

// class of a node of an n-ary tree
class Node {

public:
    int key;
    vector<Node*> child;

    // constructor
    Node(int data)
    {
        key = data;
    }
};

// Function to find immediate Smaller Element
// of a given number x
void immediateSmallerElementUtil(Node* root,
                            int x, Node** res)
{
    if (root == NULL)
        return;

    // if root is greater than res, but less
    // than x, then update res
    if (root->key < x)
        if (!(*res) || (*res)->key < root->key)
            *res = root; // Updating res

    // Number of children of root
    int numChildren = root->child.size();

    // Recursive calling for every child
    for (int i = 0; i < numChildren; i++)
        immediateSmallerElementUtil(root->child[i], x, res);

    return;
}

// Function to return immediate Smaller
// Element of x in tree
Node* immediateSmallerElement(Node* root, int x)
{
    // resultant node
    Node* res = NULL;

    // calling helper function and using
    // pass by reference
    immediateSmallerElementUtil(root, x, &res);

    return res;
}

// Driver program
int main()
{
    // Creating a generic tree
    Node* root = new Node(20);
    (root->child).push_back(new Node(2));
    (root->child).push_back(new Node(34));
    (root->child).push_back(new Node(50));
    (root->child).push_back(new Node(60));
    (root->child).push_back(new Node(70));
    (root->child[0]->child).push_back(new Node(15));
    (root->child[0]->child).push_back(new Node(20));
    (root->child[1]->child).push_back(new Node(30));
    (root->child[2]->child).push_back(new Node(40));
    (root->child[2]->child).push_back(new Node(100));
    (root->child[2]->child).push_back(new Node(20));
    (root->child[0]->child[1]->child).push_back(new Node(25));
    (root->child[0]->child[1]->child).push_back(new Node(50));

    int x = 30;

    cout << "Immediate smaller element of " << x << " is ";
    cout << immediateSmallerElement(root, x)->key << endl;

    return 0;
}

Python3

# Python code for the above approach
class Node:
    def __init__(self, key):
        self.key = key
        self.child = []

# Function to find immediate Smaller Element of a given number x
def immediateSmallerElementUtil(root, x, res):
    if root is None:
        return

    # if root is greater than res, but less than x, then update res
    if root.key < x:
        if res[0] is None or res[0].key < root.key:
            res[0] = root

    # Recursive calling for every child
    for i in range(len(root.child)):
        immediateSmallerElementUtil(root.child[i], x, res)
    return

# Function to return immediate Smaller Element of x in tree
def immediateSmallerElement(root, x):
    # resultant node
    res = [None]
    immediateSmallerElementUtil(root, x, res)
    return res[0]

if __name__ == "__main__":
    # Creating a generic tree
    root = Node(20)
    root.child.append(Node(2))
    root.child.append(Node(34))
    root.child.append(Node(50))
    root.child.append(Node(60))
    root.child.append(Node(70))
    root.child[0].child.append(Node(15))
    root.child[0].child.append(Node(20))
    root.child[1].child.append(Node(30))
    root.child[2].child.append(Node(40))
    root.child[2].child.append(Node(100))
    root.child[2].child.append(Node(20))
    root.child[0].child[1].child.append(Node(25))
    root.child[0].child[1].child.append(Node(50))

    x = 30

    print("Immediate smaller element of", x, "is", immediateSmallerElement(root, x).key)

    # This code is contributed by lokeshpotta20.

Java

import java.util.*;

// class of a node of an n-ary tree
class Node {
    int key;
    List<Node> child;

    // constructor
    Node(int data) {
        key = data;
        child = new ArrayList<>();
    }
}

// Main class
class Main {
    // Function to find immediate smaller element
    // of a given number x
    static void immediateSmallerElementUtil(Node root, int x, Node[] res) {
        if (root == null)
            return;

        // if root is greater than res, but less
        // than x, then update res
        if (root.key < x)
            if (res[0] == null || res[0].key < root.key)
                res[0] = root; // Updating res

        // Number of children of root
        int numChildren = root.child.size();

        // Recursive calling for every child
        for (int i = 0; i < numChildren; i++)
            immediateSmallerElementUtil(root.child.get(i), x, res);
    }

    // Function to return immediate smaller
    // element of x in tree
    static Node immediateSmallerElement(Node root, int x) {
        // resultant node
        Node[] res = new Node[1];

        // calling helper function and using
        // pass by reference
        immediateSmallerElementUtil(root, x, res);

        return res[0];
    }

    // Driver code
    public static void main(String[] args) {
        // Creating a generic tree
        Node root = new Node(20);
        root.child.add(new Node(2));
        root.child.add(new Node(34));
        root.child.add(new Node(50));
        root.child.add(new Node(60));
        root.child.add(new Node(70));
        root.child.get(0).child.add(new Node(15));
        root.child.get(0).child.add(new Node(20));
        root.child.get(1).child.add(new Node(30));
        root.child.get(2).child.add(new Node(40));
        root.child.get(2).child.add(new Node(100));
        root.child.get(2).child.add(new Node(20));
        root.child.get(0).child.get(1).child.add(new Node(25));
        root.child.get(0).child.get(1).child.add(new Node(50));

        int x = 30;

        System.out.print("Immediate smaller element of " + x + " is ");
        System.out.println(immediateSmallerElement(root, x).key);
    }
}

C#

// C# program for the above approach

using System;
using System.Collections.Generic;


// class of a node of an n-ary tree
class Node {
    public int key;
    public List<Node> child;

     // constructor
    public Node(int data) {
        key = data;
        child = new List<Node>();
    }
}

class GFG {
     // Function to find immediate smaller element
    // of a given number x
    static void immediateSmallerElementUtil(Node root, int x, Node[] res) {
        if (root == null) return;

         // if root is greater than res, but less
        // than x, then update res
        if (root.key < x) {
            if (res[0] == null || res[0].key < root.key) {
                res[0] = root;
            }
        }

        // Number of children of root
        int numChildren = root.child.Count;

         // Recursive calling for every child
        for (int i = 0; i < numChildren; i++) {
            immediateSmallerElementUtil(root.child[i], x, res);
        }
    }

     // Function to return immediate smaller
    // element of x in tree
    static Node immediateSmallerElement(Node root, int x) {
        Node[] res = new Node[1];

           // calling helper function and using
        // pass by reference
        immediateSmallerElementUtil(root, x, res);
        return res[0];
    }

      // Driver Code
    public static void Main() {
        Node root = new Node(20);
        root.child.Add(new Node(2));
        root.child.Add(new Node(34));
        root.child.Add(new Node(50));
        root.child.Add(new Node(60));
        root.child.Add(new Node(70));
        root.child[0].child.Add(new Node(15));
        root.child[0].child.Add(new Node(20));
        root.child[1].child.Add(new Node(30));
        root.child[2].child.Add(new Node(40));
        root.child[2].child.Add(new Node(100));
        root.child[2].child.Add(new Node(20));
        root.child[0].child[1].child.Add(new Node(25));
        root.child[0].child[1].child.Add(new Node(50));

        int x = 30;

        Console.Write("Immediate smaller element of " + x + " is ");
        Console.WriteLine(immediateSmallerElement(root, x).key);
    }
}

// This code is contributed by codebraxnzt

Javascript

class Node {
    constructor(key) {
        this.key = key;
        this.child = [];
    }
}

// Function to find immediate Smaller Element of a given number x
function immediateSmallerElementUtil(root, x, res) {
    if (root == null) {
        return;
    }

    // if root is greater than res, but less than x, then update res
    if (root.key < x) {
        if (res[0] == null || res[0].key < root.key) {
            res[0] = root;
        }
    }

    // Recursive calling for every child
    for (let i = 0; i < root.child.length; i++) {
        immediateSmallerElementUtil(root.child[i], x, res);
    }
    return;
}

// Function to return immediate Smaller Element of x in tree
function immediateSmallerElement(root, x) {
    // resultant node
    let res = [null];
    immediateSmallerElementUtil(root, x, res);
    return res[0];
}

// Creating a generic tree
let root = new Node(20);
root.child.push(new Node(2));
root.child.push(new Node(34));
root.child.push(new Node(50));
root.child.push(new Node(60));
root.child.push(new Node(70));
root.child[0].child.push(new Node(15));
root.child[0].child.push(new Node(20));
root.child[1].child.push(new Node(30));
root.child[2].child.push(new Node(40));
root.child[2].child.push(new Node(100));
root.child[2].child.push(new Node(20));
root.child[0].child[1].child.push(new Node(25));
root.child[0].child[1].child.push(new Node(50));

let x = 30;

console.log("Immediate smaller element of", x, "is", immediateSmallerElement(root, x).key);

Output

Immediate smaller element of 30 is 25

Complexity Analysis:

• Time Complexity : O(N), where N is the number of nodes in N-ary Tree. 
• Auxiliary Space : O(N), for recursive call(worst case when a node has N number of childs)