用单链表形式 1.输入两组非递减数据序列,使用链式存储方式，合并为一组数据从大到小排序输出；2 写一算法，删除带头结点的单链表L中的重复结点；

1. 合并两个非递减数据序列并从大到小排序输出的单链表算法实现：

class Node:
    def __init__(self, val):
        self.val = val
        self.next = None
        
def merge_lists(l1: Node, l2: Node) -> Node:
    dummy = Node(None)
    curr = dummy
    while l1 and l2:
        if l1.val >= l2.val:
            curr.next = l1
            l1 = l1.next
        else:
            curr.next = l2
            l2 = l2.next
        curr = curr.next
    curr.next = l1 if l1 else l2
    return dummy.next

def sort_list(head: Node) -> Node:
    if not head or not head.next:
        return head
    slow, fast = head, head.next
    while fast and fast.next:
        slow = slow.next
        fast = fast.next.next
    mid = slow.next
    slow.next = None
    left = sort_list(head)
    right = sort_list(mid)
    return merge_lists(left, right)

# 示例
l1 = Node(1)
l1.next = Node(2)
l1.next.next = Node(4)

l2 = Node(1)
l2.next = Node(3)
l2.next.next = Node(4)

merged_list = merge_lists(l1, l2)
sorted_list = sort_list(merged_list)

while sorted_list:
    print(sorted_list.val)
    sorted_list = sorted_list.next

2. 删除带头结点的单链表L中的重复结点的算法实现：

class Node:
    def __init__(self, val):
        self.val = val
        self.next = None

def delete_duplicate(head: Node) -> Node:
    if not head or not head.next:
        return head
    dummy = Node(None)
    dummy.next = head
    pre = dummy
    curr = head
    while curr:
        if curr.next and curr.val == curr.next.val:
            while curr.next and curr.val == curr.next.val:
                curr = curr.next
            pre.next = curr.next
        else:
            pre = pre.next
        curr = curr.next
    return dummy.next

# 示例
head = Node(None)
head.next = Node(1)
head.next.next = Node(1)
head.next.next.next = Node(2)
head.next.next.next.next = Node(3)
head.next.next.next.next.next = Node(3)

new_head = delete_duplicate(head)
while new_head:
    print(new_head.val)
    new_head = new_head.next