Используя только списки, вы можете добиться этого с помощью нескольких простых циклов для и .copy() :

def mergeLists(list1, list2):
    # Exit if list2 is empty
    if not len(list2):
        return list1
    # Copy the content of list2 into merged list
    merged = list2.copy()

    # Create a list for storing temporary elements
    elements = []
    # Create a variable for storing previous element found in both lists
    previous = None

    # Loop through the elements of list1
    for e in list1:
        # Append the element to "elements" list if it's not in list2
        if e not in merged:
            elements.append(e)

        # If it is in list2 (is a common element)
        else:

            # Loop through the stored elements
            for x in elements:
                # Insert all the stored elements after the previous common element
                merged.insert(previous and merged.index(previous) + 1 or 0, x)
            # Save new common element to previous
            previous = e
            # Empty temporary elements
            del elements[:]

    # If no more common elements were found but there are elements still stored
    if len(elements)
        # Insert them after the previous match
        for e in elements:
            merged.insert(previous and merged.index(previous) + 1 or 0, e)
    # Return the merged list
    return merged

In [1]: keys1 = ["A", "B",      "D",      "F", "G", "H"]
In [2]: keys2 = ["A",      "C", "D", "E", "F",      "H"]
In [3]: mergeLists(keys1, keys2)
Out[3]: ["A", "B", "C", "D", "E", "F", "G", "H"]

Английский язык не является моим первым языком, и это довольно сложно объяснить, но если вы заботитесь об объяснении, вот что он делает:

• Существует локальный список, называемый elements , который может хранить временные элементы.
• Существует локальная переменная с именем previous , которая хранит предыдущий элемент, который был в обоих списках.
• Когда он найдет элемент, который НЕ находится в list2 , но находится в list1 , он добавит этот элемент в список elements и продолжит цикл.
• Когда он попадает в элемент, который находится в обоих списках, он проходит через список elements , добавляя все элементы после previous в list2 .
• Новое совпадение затем сохраняется в previous и elements сбрасывается на [] , и цикл продолжается.
• Начало списков и конец списков подсчитывается как общий элемент, если первый или последний элемент не является общим элементом в обоих списках.

Таким образом, он всегда будет следовать этому формату:

1. Предыдущий общий элемент
2. Элементы из списка1, между двумя общими элементами
3. Элементы в списке2, между двумя общими элементами
4. Новый общий элемент

Так, например:

l1 = ["A", "B", "C",      "E"]
l2 = ["A",           "D", "E"]

1. The revious common element A will be first in the merged list.
2. Elements from l1 between the previous common element A and the new common element E will be inserted right after A.
3. Elements from l2 between the previous common elmeent A and the new common elmeent E will be inserted right after the elements from l1.
4. The new common element E will be last element.

5. Back to step 1 if more common elements found.

   ["A", "B", "C", "D", "E"]

Недавно я столкнулся с подобной проблемой при реализации функции. Сначала я попытался четко определить постановку проблемы. Если я правильно понимаю, вот описание проблемы

Постановка задачи

Напишите функцию merge_lists, которая объединит список списков с перекрывающимися элементами, сохраняя при этом порядок элементов.

Ограничения

1. Если элемент A находится перед элементом B во всех списках, где они встречаются вместе, то элемент A должен предшествовать пункту B в конечном списке также

2. Если порядок обмена A и пункт B в разных списках, то есть в некоторых списках A предшествует B, а в некоторых других B предшествует A, тогда порядок A и B в конечном списке должен быть таким же, как и их порядок в первом списке, где они встречаются вместе. То есть, если A предшествует B в l1 и B предшествует A в l2, тогда A должен предшествовать B в конечном списке

3. Если элементы A и элемент B не встречаются вместе в любом списке, их порядок должен определяться положением списка, в котором каждый из них встречается первым. То есть, если элемент A находится в l1 и l3, элемент B находится в l2 и l6, тогда порядок в конечном списке должен быть A, а затем B

Тестовый кейс 1:

Входные данные:

l1 = [«Тип и размер», «Ориентация», «Материал», «Местоположения», «Тип передней печати», «Обратный тип печати»]

l2 = [«Тип и размер», «Материал», «Местоположения», «Тип передней печати», «Размер передней печати», «Обратный тип печати», «Назад размер печати»]

l3 = ["Ориентация", "Материал", "Местоположения", "Цвет", "Тип передней печати"]

merge_lists ([l1, l2, l3])

Вывод:

[«Тип и размер», «Ориентация», «Материал», «Местоположения», «Цвет», «Тип передней печати», «Размер передней печати», «Обратный тип печати», «Назад размер печати»]

Тестовый пример 2:

Входные данные:

l1 = ["T", "V", "U", "B", "C", "I", "N"]

l2 = ["Y", "V", "U", "G", "B", "I"]

l3 = ["X", "T", "V", "M", "B", "C", "I"]

l4 = ["U", "P", "G"]

merge_lists ([l1, l2, l3, l4])

Вывод:

['Y', 'X', 'T', 'V', 'U', 'M', 'P', 'G', 'B', 'C', 'I', 'N']

Тестовый кейс 3:

Входные данные:

l1 = ["T", "V", "U", "B", "C", "I", "N"]

l2 = ["Y", "U", "V", "G", "B", "I"]

l3 = ["X", "T", "V", "M", "I", "C", "B"]

l4 = ["U", "P", "G"]

merge_lists ([l1, l2, l3, l4])

Вывод:

['Y', 'X', 'T', 'V', 'U', 'M', 'P', 'G', 'B', 'C', 'I', 'N']

Решение

I arrived at a reasonable Решение which solved it correctly for all the data I had. (It might be wrong for some other data set. Will leave it for others to comment that). Here is the Решение

def remove_duplicates(l):
    return list(set(l))

def flatten(list_of_lists):
    return [item for sublist in list_of_lists for item in sublist]

def difference(list1, list2):
    result = []
    for item in list1:
        if item not in list2:
            result.append(item)
    return result

def preceding_items_list(l, item):
    if item not in l:
        return []
    return l[:l.index(item)]

def merge_lists(list_of_lists):
    final_list = []
    item_predecessors = {}

    unique_items = remove_duplicates(flatten(list_of_lists))
    item_priorities = {}

    for item in unique_items:
        preceding_items = remove_duplicates(flatten([preceding_items_list(l, item) for l in list_of_lists]))
        for p_item in preceding_items:
            if p_item in item_predecessors and item in item_predecessors[p_item]:
                preceding_items.remove(p_item)
        item_predecessors[item] = preceding_items
    print "Item predecessors ", item_predecessors

    items_to_be_checked = difference(unique_items, item_priorities.keys())
    loop_ctr = -1
    while len(items_to_be_checked) > 0:
        loop_ctr += 1
        print "Starting loop {0}".format(loop_ctr)
        print "items to be checked ", items_to_be_checked
        for item in items_to_be_checked:
            predecessors = item_predecessors[item]
            if len(predecessors) == 0:
                item_priorities[item] = 0
            else:
                if all(pred in item_priorities for pred in predecessors):
                    item_priorities[item] = max([item_priorities[p] for p in predecessors]) + 1
        print "item_priorities at end of loop ", item_priorities
        items_to_be_checked = difference(unique_items, item_priorities.keys())
        print "items to be checked at end of loop ", items_to_be_checked
        print

    final_list = sorted(unique_items, key=lambda item: item_priorities[item])
    return final_list

Я также открыл исходный код как часть библиотеки с именем toolspy. Таким образом, вы можете просто сделать это

pip install toolspy

from toolspy import merge_lists
lls=[['a', 'x', 'g'], ['x', 'v', 'g'], ['b', 'a', 'c', 'x']]
merge_lists(lls)