Considere que hay algunas listas de enteros como:

#--------------------------------------
0 [0,1,3]
1 [1,0,3,4,5,10,...]
2 [2,8]
3 [3,1,0,...]
...
n []
#--------------------------------------

La pregunta es fusionar listas que tengan al menos un elemento común. Por lo tanto, los resultados solo para la parte dada serán los siguientes:

#--------------------------------------
0 [0,1,3,4,5,10,...]
2 [2,8]
#--------------------------------------

Cuál es la forma más eficiente de hacer esto en datos grandes (los elementos son solo números)? Estree estructura algo para pensar? Hago el trabajo ahora convirtiendo listas asets e iterando para intersecciones, ¡pero es lento! Además, ¡tengo la sensación de que es tan elemental! Además, la implementación carece de algo (desconocido) porque algunas listas permanecen sin fusionar alguna vez. Habiendo dicho eso, si estaba proponiendo una auto implementación, sea generoso y proporcione un código de muestra simple [aparentementePitó es mi favorito :)] o pesudocódigo.
Actualización 1: Aquí está el código que estaba usando:

#--------------------------------------
lsts = [[0,1,3],
        [1,0,3,4,5,10,11],
        [2,8],
        [3,1,0,16]];
#--------------------------------------

La función es ¡¡calesa!):

#--------------------------------------
def merge(lsts):
    sts = [set(l) for l in lsts]
    i = 0
    while i < len(sts):
        j = i+1
        while j < len(sts):
            if len(sts[i].intersection(sts[j])) > 0:
                sts[i] = sts[i].union(sts[j])
                sts.pop(j)
            else: j += 1                        #---corrected
        i += 1
    lst = [list(s) for s in sts]
    return lst
#--------------------------------------

El resultado es

#--------------------------------------
>>> merge(lsts)
>>> [0, 1, 3, 4, 5, 10, 11, 16], [8, 2]]
#--------------------------------------

Actualización 2: Según mi experiencia, el código dado porNiklas Baumstark debajo demostró ser un poco más rápido para los casos simples. Todavía no se ha probado el método proporcionado por "Hooked", ya que es un enfoque completamente diferente (por cierto, parece interesante). El procedimiento de prueba para todo esto podría ser realmente difícil o imposible de garantizar con los resultados. El conjunto de datos real que usaré es tan grande y complejo, por lo que es imposible rastrear cualquier error simplemente repitiendo. Es decir, necesito estar 100% satisfecho de la confiabilidad del método antes de colocarlo en su lugar dentro de un código grande como módulo. Simplemente por ahora Niklasl método de @ es más rápido y la respuesta para conjuntos simples es correcta, por supuesto.
Sin embargo, ¿cómo puedo estar seguro de que funciona bien para un conjunto de datos realmente grande? ¡Ya que no podré rastrear los errores visualmente!

Actualización 3: Tenga en cuenta que la confiabilidad del método es mucho más importante que la velocidad para este problema. Espero poder traducir el código de Python a Fortran para obtener el máximo rendimiento finalmente.

Actualización 4:
Hay muchos puntos interesantes en esta publicación y respuestas generosas, comentarios constructivos. Recomendaría leer todo a fondo. Acepte mi agradecimiento por el desarrollo de la pregunta, respuestas sorprendentes y comentarios constructivos y discusión.