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

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

Python3

# Python3 Program to sort a linked list
# 0s, 1s or 2s by changing links
import math
 
# Link list node
class Node:
    def __init__(self, data):
        self.data = data
        self.next = None
 
#Node* newNode( data)
 
# Sort a linked list of 0s, 1s
# and 2s by changing pointers.
def sortList(head):
    if (head == None or
        head.next == None):
        return head
 
    # Create three dummy nodes to point
    # to beginning of three linked lists.
    # These dummy nodes are created to
    # avoid many None checks.
    zeroD = Node(0)
    oneD = Node(0)
    twoD = Node(0)
 
    # Initialize current pointers for
    # three lists and whole list.
    zero = zeroD
    one = oneD
    two = twoD
 
    # Traverse list
    curr = head
    while (curr):
        if (curr.data == 0):
            zero.next = curr
            zero = zero.next
            curr = curr.next
        elif(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) if (oneD.next)
                            else (twoD.next)
    one.next = twoD.next
    two.next = None
 
    # Updated head
    head = zeroD.next
 
    # Delete dummy nodes
    return head
 
# Function to create and return
# a node
def newNode(data):
     
    # Allocating space
    newNode = Node(data)
 
    # Inserting the required data
    newNode.data = data
    newNode.next = None
    return newNode
 
# Function to print linked list
def prList(node):
    while (node != None):
        print(node.data, end = " ")
        node = node.next
     
# Driver Code
if __name__=='__main__':
     
    # Creating the list 1.2.4.5
    head = newNode(1)
    head.next = newNode(2)
    head.next.next = newNode(0)
    head.next.next.next = newNode(1)
 
    print("Linked List Before Sorting")
    prList(head)
 
    head = sortList(head)
 
    print("Linked List After Sorting")
    prList(head)
# This code is contributed by Srathore

输出 ：

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

复杂性分析：

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

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