Unir dos listas enlazadas sin duplicados.

Dadas dos listas enlazadas ordenadas, donde el resultado debe ser la unión sin duplicados.

No se permite crear nuevos nodos.
La lista resultante estará compuesta por los elementos de las listas originales.

Las entradas son dos listas separadas por una línea vacía:

L1 -> 2 3 3 4 4 4 5

L2 -> 3 4 5 5 6 7

Resultado -> 2 3 4 5 6 7

Tengo mi solución a continuación, pero se crea un nuevo nodo en la función de unión.

¿Hay alguna manera sencilla de cambiar la función de unión con la lógica de no crear ningún nodo nuevo y eliminar duplicados?

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

def PrintLinkedList(p):
    print("Resultado:", end=" ")
    while p != None:
        print(p.data, end=" ")
        p = p.next
    print(".")

def ReadLinkedList():
    first = None
    last = None
    r = input()
    while r != "":
        row = r.split()
        if len(row) == 0:
            break
        for s in row:
            p = Node(int(s), None)
            if first == None:
                first = p
            else:
                last.next = p
            last = p
        r = input()
    return first

def dedup(head):
    current = head
    while current:
        runner = current
        # Check, until runner.next is not None.
        while runner.next:
            if current.data == runner.next.data:
                runner.next = runner.next.next
            else:
                runner = runner.next
        current = current.next

def Union(a, b):

    # Un nodo ficticio para almacenar el resultado
    nodoFicticio = Node(0)
    headA = a
    headB = b

    # Tail almacena el último nodo
    tail = nodoFicticio
    while True:

        # Si cualquiera de las listas queda completamente vacía,
        # junta directamente todos los elementos de la otra lista
        if headA is None:
            tail.next = headB
            break
        if headB is None:
            tail.next = headA
            break

        # Compara las x de las listas y la que sea más pequeña se
        # agrega al final de la lista fusionada y se cambia la cabeza
        if headA.data <= headB.data:
            tail.next = headA
            headA = headA.next
        else:
            tail.next = headB
            headB = headB.next

        # Avanza la cola
        tail = tail.next

    # Elimina duplicados y devuelve la cabeza de la lista fusionada
    dedup(nodoFicticio.next)
    return nodoFicticio.next