用任意指针指向链表中下一个更高值节点的Java程序

给定单链表，每个节点都有一个当前指向 NULL 的附加“任意”指针。需要使“任意”指针指向下一个更高值的节点。

我们强烈建议您最小化您的浏览器并先自己尝试

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

一个有效的解决方案在 O(nLogn) 时间内工作。这个想法是对链表使用合并排序。
1）遍历输入列表并将下一个指针复制到每个节点的仲裁指针。
2) 对仲裁指针形成的链表进行归并排序。

下面是上述思想的实现。所有的合并排序函数都取自这里。此处修改了所采用的函数，以便它们在仲裁指针而不是下一个指针上工作。

C++

// Java program to populate arbit pointers 
// to next higher value using merge sort
class LinkedList
{
    static Node head;
  
    // Link list node 
    static class Node
    {
        int data;
        Node next, arbit;
  
        Node(int data) 
        {
            this.data = data;
            next = null;
            arbit = null;
        }
    }
  
    // Utility function to print result 
    // linked list
    void printList(Node node, Node anode)
    {
        System.out.println(
        "Traversal using Next Pointer");
        while (node != null)
        {
            System.out.print(node.data + " ");
            node = node.next;
        }
  
        System.out.println(
        "Traversal using Arbit Pointer");
        while (anode != null)
        {
            System.out.print(
            anode.data + " ");
            anode = anode.arbit;
        }
    }
  
    // This function populates arbit pointer 
    // in every node to the next higher value. 
    // And returns pointer to the node with 
    // minimum value
    private Node populateArbit(Node start)
    {
        Node temp = start;
  
        // Copy next pointers to arbit 
        // pointers
        while (temp != null)
        {
            temp.arbit = temp.next;
            temp = temp.next;
        }
  
        // Do merge sort for arbitrary pointers 
        // and return head of arbitrary pointer 
        // linked list
        return MergeSort(start);
    }
  
    /* Sorts the linked list formed by 
       arbit pointers (does not change
       next pointer or data) */
    private Node MergeSort(Node start)
    {        
        // Base case -- length 
        // 0 or 1 
        if (start == null || 
            start.arbit == null)
        {
            return start;
        }
  
        /* Split head into 'middle' and 
           'nextofmiddle' sublists */
        Node middle = getMiddle(start);
        Node nextofmiddle = middle.arbit;
  
        middle.arbit = null;
  
        // Recursively sort the sublists 
        Node left = MergeSort(start);
        Node right = MergeSort(nextofmiddle);
  
        /* answer = merge the two sorted 
           lists together */
        Node sortedlist = SortedMerge(left, right);
  
        return sortedlist;
    }
  
    // Utility function to get the middle 
    // of the linked list
    private Node getMiddle(Node source)
    {
        // Base case
        if (source == null)
            return source;
        Node fastptr = source.arbit;
        Node slowptr = source;
  
        // Move fastptr by two and slow 
        // ptr by one. Finally slowptr 
        // will point to middle node
        while (fastptr != null)
        {
            fastptr = fastptr.arbit;
            if (fastptr != null)
            {
                slowptr = slowptr.arbit;
                fastptr = fastptr.arbit;
            }
        }
        return slowptr;
    }
  
    private Node SortedMerge(Node a, 
                             Node b)
    {
        Node result = null;
  
        // Base cases 
        if (a == null)
            return b;
        else if (b == null)
            return a;
  
        // Pick either a or b, and recur 
        if (a.data <= b.data)
        {
            result = a;
            result.arbit = 
            SortedMerge(a.arbit, b);
        }
        else
        {
            result = b;
            result.arbit = SortedMerge(a, b.arbit);
        }
  
        return result;
    }
  
    // Driver code
    public static void main(String[] args)
    {
        LinkedList list = new LinkedList();
  
        /* Let us create the list shown
           above */
        list.head = new Node(5);
        list.head.next = new Node(10);
        list.head.next.next = new Node(2);
        list.head.next.next.next = new Node(3);
  
        /* Sort the above created Linked List */
        Node ahead = list.populateArbit(head);
  
        System.out.println("Result Linked List is:");
        list.printList(head, ahead);
    }
}
// This code is contributed by shubham96301

输出：

Result Linked List is:
Traversal using Next Pointer
5, 10, 2, 3,
Traversal using Arbit Pointer
2, 3, 5, 10,

有关更多详细信息，请参阅关于使用任意指针指向链表中的下一个更高值节点的完整文章！