用于将仲裁指针指向链接列表中的最大值右侧节点的Java程序

给定单链表，每个节点都有一个当前指向 NULL 的附加“任意”指针。我们需要将“任意”指针指向右侧链表中的最大值节点。

一个简单的解决方案是一个一个地遍历所有节点。对于每个节点，找到右侧具有最大值的节点并更改下一个指针。该解决方案的时间复杂度为 O(n ² )。

一个有效的解决方案可以在 O(n) 时间内工作。以下是步骤。

1. 反转给定的链表。
2. 开始遍历链表，存储目前遇到的最大值节点。使每个节点的仲裁指向最大值。如果当前节点中的数据超过了迄今为止的max节点，则更新max。
3. 反向修改链表并返回头部。

以下是上述步骤的实现。

Java

// Java program to point arbit pointers 
// to highest value on its right 
class GfG{ 
  
// 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    " +
                       "Next Pointer    " +
                       "Arbit Pointer"); 
    while (node != null) 
    { 
        System.out.print(node.data + 
                         "        "); 
  
        if (node.next != null) 
            System.out.print(node.next.data + 
                             "        "); 
        else
            System.out.print("NULL" +
                             "        "); 
  
        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(5); 
    head.next = newNode(10); 
    head.next.next = newNode(2); 
    head.next.next.next = newNode(3); 
  
    head = populateArbit(head); 
  
    System.out.println(
           "Resultant Linked List is: "); 
    printNextArbitPointers(head); 
}
} 
// This code is contributed by Prerna Saini.

输出：

Resultant Linked List is: 
Node    Next Pointer    Arbit Pointer
5               10              10
10              2               3
2               3               3
3               NULL            NULL

递归解决方案：
我们可以递归到达最后一个节点，从最后遍历链表。递归解决方案不需要反转链表。我们还可以使用堆栈代替递归来临时保存节点。感谢 Santosh Kumar Mishra 提供此解决方案。

Java

// Java program to point arbit pointers 
// to highest value on its right
class GfG
{
    // Link list node 
    static class Node
    {
        int data;
        Node next, arbit;
    }
  
    static Node maxNode;
  
    // This function populates arbit pointer 
    // in every node to the greatest value 
    // to its right.
    static void populateArbit(Node head)
    {
        // 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
    static void printNextArbitPointers(Node node)
    {
        System.out.println("Node    " + 
                           "Next Pointer    " + 
                           "Arbit Pointer");
        while (node != null)
        {
            System.out.print(node.data + 
                             "            ");
  
            if (node.next != null)
                System.out.print(node.next.data + 
                                 "                ");
            else
                System.out.print("NULL" +
                                 "            ");
  
            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(5);
        head.next = newNode(10);
        head.next.next = newNode(2);
        head.next.next.next = newNode(3);
  
        populateArbit(head);
  
        System.out.println(
               "Resultant Linked List is: ");
        printNextArbitPointers(head);
    }
}
// This code is contributed by shubham96301    

输出：

Resultant Linked List is: 
Node    Next Pointer    Arbit Pointer
5               10              10
10              2               3
2               3               3
3               NULL            NULL

请参考完整文章 Point arbit pointer to maximum value right side node in alinked list 了解更多详情！