Point arbit pointer to greatest value right-side node in a linked list

#include<stdio.h>
#include<stdlib.h>

struct Node
{
    int data;
    struct Node* next, *arbit;
};
 
// This function populates arbit pointer in every
// node to the greatest value to its right.
void populateArbit(struct Node *head)
{
    // using static maxNode to keep track of maximum
    // orbit node address on right side
    static struct Node *maxNode;
 
    // if head is null simply return the list
    if (head == NULL)
        return;
 
    /* if head->next is null it means we reached at
       the last node just update the max and maxNode */
    if (head->next == NULL)
    {
        maxNode = head;
        return;
    }
 
    /* Calling the populateArbit to the next node */
    populateArbit(head->next);
 
    /* updating the arbit node of the current
     node with the maximum value on the right side */
    head->arbit = maxNode;
 
    /* if current Node value id greater then
     the previous right node then  update it */
    if (head->data > maxNode->data)
        maxNode = head;
 
   return;
}
 
// Utility function to print result linked list
void printNextArbitPointers(struct Node *node)
{
    printf("Node\tNext Pointer\tArbit Pointer\n");
    while (node!=NULL)
    {
        printf("%d\t\t",node->data);
 
        if(node->next)
            printf("%d \t\t",node->next->data);
        else printf("\t\t","NULL");
 
        if(node->arbit)
            printf("%d ",node->arbit->data);
        else printf("NULL");
 
        printf("\n");
        node = node->next;
    }
}
 
/* Function to create a new node with given data */
struct Node *newNode(int data)
{
    struct Node* new_node = (struct Node*)malloc(sizeof(struct Node*));
    new_node->data = data;
    new_node->next = NULL;
    return new_node;
}
 
/* Driver program to test above functions*/
int main()
{
    struct Node *head = newNode(5);
    head->next = newNode(10);
    head->next->next = newNode(2);
    head->next->next->next = newNode(3);
 
    populateArbit(head);
 
    printf("Resultant Linked List is: \n");
    printNextArbitPointers(head);
 
    return 0;
}

class PrepBytes
{

/* Link list node */
static class Node
{
	int data;
	Node next, arbit;
}

/* Function to reverse the linked list */
static Node reverse(Node head)
{
	Node prev = null, current = head, next = null;
	while (current != null)
	{
		next = current.next;
		current.next = prev;
		prev = current;
		current = next;
	}
	return prev;
}

// This function populates arbit pointer in every
// node to the greatest value to its right.
static Node populateArbit(Node head)
{
	// Reverse given linked list
	head = reverse(head);

	// Initialize pointer to maximum value node
	Node max = head;

	// Traverse the reversed list
	Node temp = head.next;
	while (temp != null)
	{
		// Connect max through arbit pointer
		temp.arbit = max;

		// Update max if required
		if (max.data < temp.data)
			max = temp;

		// Move ahead in reversed list
		temp = temp.next;
	}

	// Reverse modified linked list and return
	// head.
	return reverse(head);
}

// Utility function to print result linked list
static void printNextArbitPointers(Node node)
{
	System.out.println("Node\tNext Pointer\tArbit Pointer");
	while (node != null)
	{
		System.out.print(node.data + "\t\t");

		if (node.next != null)
			System.out.print(node.next.data + "\t\t");
		else
			System.out.print("NULL" +"\t\t");

		if (node.arbit != null)
			System.out.print(node.arbit.data);
		else
			System.out.print("NULL");

		System.out.println();
		node = node.next;
	}
}

/* Function to create a new node with given data */
static Node newNode(int data)
{
	Node new_node = new Node();
	new_node.data = data;
	new_node.next = null;
	return new_node;
}

/* Driver code*/
public static void main(String[] args)
{
	Node head = newNode(7);
	head.next = newNode(2);
	head.next.next = newNode(12);
	head.next.next.next = newNode(1);
	head.next.next.next.next = newNode(8);

	head = populateArbit(head);

	System.out.println("Resultant Linked List is: ");
	printNextArbitPointers(head);

}
}

# Node class
class Node:

	def __init__(self, data):
		self.data = data
		self.next = None
		self.arbit = None

# Function to reverse the linked list
def reverse(head):

	prev = None
	current = head
	next = None
	while (current != None):
	
		next = current.next
		current.next = prev
		prev = current
		current = next
	
	return prev

# This function populates arbit pointer in every
# node to the greatest value to its right.
def populateArbit(head):

	head = reverse(head)

	max = head

	temp = head.next
	while (temp != None):

		temp.arbit = max

		if (max.data < temp.data):
			max = temp

		temp = temp.next

	return reverse(head)

# Utility function to print result linked list
def printNextArbitPointers(node):

	print("Node\tNext Pointer\tArbit Pointer\n")
	while (node != None):
	
		print( node.data , "\t\t",end = "")

		if (node.next != None):
			print( node.next.data , "\t\t",end = "")
		else :
			print( "None" , "\t\t",end = "")

		if (node.arbit != None):
			print( node.arbit.data,end = "")
		else :
			print( "None",end = "")
		
		print("\n")
		node = node.next
	
# Function to create a new node with given data
def newNode(data):

	new_node = Node(0)
	new_node.data = data
	new_node.next = None
	return new_node


head = newNode(7)
head.next = newNode(2)
head.next.next = newNode(12)
head.next.next.next = newNode(1)
head.next.next.next.next = newNode(8)

head = populateArbit(head)

print("Resultant Linked List is: \n")
printNextArbitPointers(head)