用于通过更改链接对 0、1 和 2 的链表进行排序的Java程序

给定一个由 0、1 和 2 组成的链表，对它进行排序。
例子：

Input: 2->1->2->1->1->2->0->1->0
Output: 0->0->1->1->1->1->2->2->2
The sorted Array is 0, 0, 1, 1, 1, 1, 2, 2, 2.

Input: 2->1->0
Output: 0->1->2
The sorted Array is 0, 1, 2

方法 1：在下面的帖子中讨论了一个通过更改节点数据来工作的解决方案。
对 0s、1s 和 2s 的链表进行排序
当这些值具有与之关联的数据时，上述解决方案不起作用。
例如，这三个代表三种颜色以及与颜色相关的不同类型的对象，并根据颜色对对象进行排序（通过链表连接）。

方法 2：在这篇文章中，讨论了一种通过更改链接来工作的新解决方案。
方法：遍历链表。维护 3 个名为 0、1 和 2 的指针，分别指向包含 0、1 和 2 的链表的当前结束节点。对于每个遍历的节点，我们将其附加到其相应列表的末尾。最后，我们链接所有三个列表。为了避免许多空检查，我们使用了三个虚拟指针 zeroD、oneD 和 twoD，它们作为三个列表的虚拟标题。

Java

// Java Program to sort a linked list 
// 0s, 1s or 2s by changing links 
public class Sort012 
{
    // Sort a linked list of 0s, 1s 
    // and 2s by changing pointers.
    public static Node sortList(Node head)
    {
        if(head==null || head.next==null)
        {
            return head;
        }
  
        // Create three dummy nodes to point to 
        // beginning of three linked lists. These 
        // dummy nodes are created to avoid many 
        // null checks. 
        Node zeroD = new Node(0); 
        Node oneD = new Node(0); 
        Node twoD = new Node(0); 
  
        // Initialize current pointers for three 
        // lists and whole list. 
        Node zero = zeroD, one = oneD, two = twoD; 
        // Traverse list 
        Node curr = head; 
        while (curr!=null) 
        { 
            if (curr.data == 0) 
            { 
                zero.next = curr; 
                zero = zero.next; 
                curr = curr.next; 
            }
            else if (curr.data == 1) 
            { 
                one.next = curr; 
                one = one.next; 
                curr = curr.next; 
            } 
            else 
            { 
                two.next = curr; 
                two = two.next; 
                curr = curr.next; 
            } 
        }
        // Attach three lists 
        zero.next = (oneD.next!=null) ? 
                    (oneD.next) : (twoD.next); 
        one.next = twoD.next; 
        two.next = null;
  
        // Updated head 
        head = zeroD.next;
        return head;
    }
  
    // Function to create and return a node 
    public static Node newNode(int data) 
    { 
        // Allocating space 
        Node newNode = new Node(data);
        newNode.next = null; 
        return newNode;
    } 
    
    // Function to print linked list 
    public static void printList(Node node) 
    { 
        while (node != null) 
        { 
            System.out.print(node.data+" ");
            node = node.next; 
        } 
    }
  
    Driver code
    public static void main(String args[]) 
    {
        Node head = new Node(1); 
        head.next = new Node(2); 
        head.next.next = new Node(0); 
        head.next.next.next = new Node(1);
        System.out.println(
        "Linked List Before Sorting");
        printList(head); 
        head = sortList(head);  
        System.out.println(
        "Linked List After Sorting");
        printList(head); 
    }
}
  
class Node
{
    int data;
    Node next;
    Node(int data)
    {
        this.data=data;
    }
}
//This code is contributed by Gaurav Tiwari

输出 ：

Linked List Before Sorting
1  2  0  1  
Linked List After Sorting
0  1  1  2  

复杂性分析：

• 时间复杂度： O(n)，其中 n 是链表中的节点数。
  只需要遍历一次链表。
• 辅助空间： O(1)。
  因为不需要额外的空间。

请参阅完整文章通过更改链接对 0、1 和 2 的链表进行排序以获取更多详细信息！