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

给定一个由 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，它们作为三个列表的虚拟标题。

Javascript

  
// JavaScript Program to sort a
// linked list 0s, 1s 
// or 2s by changing links 
class Node 
{
    constructor(val) 
    {
        this.data = val;
        this.next = null;
    }
}
  
// Sort a linked list of 0s, 1s 
// and 2s by changing pointers.
function sortList(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 
    // a function many null checks.
    var zeroD = new Node(0);
    var oneD = new Node(0);
    var twoD = new Node(0);
  
    // Initialize current pointers for 
    // three lists and whole list.
    var zero = zeroD, one = oneD, 
        two = twoD;
          
    // Traverse list
    var 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
function newNode(data) 
{
    // Allocating space
    var newNode = new Node(data);
    newNode.next = null;
    return newNode;
}
  
// Function to print linked list 
function printList(node) 
{
    while (node != null) 
    {
        document.write(node.data + " ");
        node = node.next;
    }
}
  
var head = new Node(1); 
head.next = new Node(2); 
head.next.next = new Node(0); 
head.next.next.next = new Node(1);
document.write(
"Linked List Before Sorting<br/>");
printList(head); 
head = sortList(head);  
document.write(
"<br/>Linked List After Sorting<br/>");
printList(head); 
// This code is contributed by gauravrajput1 

输出 ：

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

复杂性分析：

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

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