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

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

C++

// C++ Program to sort a linked list 
// 0s, 1s or 2s by changing links
#include 
  
// Link list node 
struct Node 
{
    int data;
    struct Node* next;
};
  
Node* newNode(int data);
  
// Sort a linked list of 0s, 1s 
// and 2s by changing pointers.
Node* sortList(Node* head)
{
    if (!head || !(head->next))
        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 = newNode(0);
    Node* oneD = newNode(0);
    Node* twoD = newNode(0);
  
    // Initialize current pointers for 
    // three lists and whole list.
    Node* zero = zeroD, *one = oneD, 
        *two = twoD;
  
    // Traverse list
    Node* curr = head;
    while (curr) 
    {
        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) ? 
                 (oneD->next) : (twoD->next);
    one->next = twoD->next;
    two->next = NULL;
  
    // Updated head
    head = zeroD->next;
  
    // Delete dummy nodes
    delete zeroD;
    delete oneD;
    delete twoD;
  
    return head;
}
  
// Function to create and return a node
Node* newNode(int data)
{
    // Allocating space
    Node* newNode = new Node;
  
    // Inserting the required data
    newNode->data = data;
    newNode->next = NULL;
}
  
// Function to print linked list 
void printList(struct Node* node)
{
    while (node != NULL)
    {
        printf("%d  ", node->data);
        node = node->next;
    }
    printf("");
}
  
// Driver code
int main(void)
{
    // Creating the list 1->2->4->5
    Node* head = newNode(1);
    head->next = newNode(2);
    head->next->next = newNode(0);
    head->next->next->next = newNode(1);
  
    printf("Linked List Before Sorting");
    printList(head);
  
    head = sortList(head);
  
    printf("Linked List After Sorting");
    printList(head);
  
    return 0;
}

输出：

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

复杂性分析：

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

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