Алгоритм объединения двух списков без сравнения между ними

похоже, что он будет использовать вырожденную форму топологической сортировки.

EDIT 2:

теперь с комбинированный режим:

import itertools

list1 = [1, 2, 'c', 4, 5, 'f', 7]
list2 = ['a', 'b', 'c', 'd', 'e', 'f', 'g']

ibase = 0
result = []

for n1, i1 in enumerate(list1):
  for n2, i2 in enumerate(itertools.islice(list2, ibase, None, 1)):
    if i1 == i2:
      result.extend(itertools.islice(list2, ibase, ibase + n2))
      result.append(i2)
      ibase = n2 + ibase + 1
      break
  else:
    result.append(i1)
result.extend(itertools.islice(list2, ibase, None, 1))

print result

было бы достаточно объединить два списка? Он сохраняет относительную сортированность элементов из a и элементов из b.

тогда это просто вопрос удаления дубликатов.

EDIT: хорошо, после обсуждения комментариев (и учитывая дополнительное условие, что a_i=b_i & a_j=b_j & a_i<a_j => b_i<b-J), вот разумное решение:

1. определить элементы, общие для обоих списков. Это O (n²) для наивного алгоритма можно улучшить его.

2. (необязательно) убедитесь, что общие записи находятся в одном порядке в обоих списках.

3. построить список результатов: все элементы a, которые находятся перед первым общим элементом, за которым следуют все элементы b перед первым общим элементом, за которым следует первый общий элемент и так далее.

учитывая проблему, как вы ее выразили, у меня такое чувство, что проблема может не иметь решения. Предположим, что у вас есть две пары элементов {a_1, b_1} и {a_2, b_2} здесь a_1 < a_2 в порядке а, и b_1 > b_2 в порядке B. теперь предположим, что a_1 = b_1 и a_2 = b_2 согласно оператору равенства для A и B. В этом сценарии я не думаю, что вы можете создать объединенный список, который удовлетворяет требованию заказа подсписка.

в любом случае, есть алгоритм это должно сработать. (Закодировано на Java-ish ...)

List<A> alist = ...
List<B> blist = ...
List<Object> mergedList = new SomeList<Object>(alist);
int mergePos = 0;
for (B b : blist) {
    boolean found = false;
    for (int i = mergePos; i < mergedList.size(); i++) {
        if (equals(mergedList.get(i), b)) {
            found = true; break;
        }
    }
    if (!found) {
        mergedList.insertBefore(b, mergePos);
        mergePos++;
    }
}

этот алгоритм O(N**2) в худшем случае, и O(N) в лучшем случае. (Я просматриваю некоторые детали реализации Java ... например, объединение итерации списка и вставки без серьезного штрафа за сложность ... но я думаю, что в данном случае это возможно.)

алгоритм игнорирует патологию, упомянутую в первом абзаце, и другие патологии; например, что элемент B может быть " равен" несколько элементов A или наоборот. Чтобы справиться с этим, алгоритм должен проверить каждого b против всех элементов mergedList, которые не являются экземплярами B. Что делает алгоритм O(N**2) в лучшем случае.

Если элементы хэшируются, это можно сделать за O (N) время, где N-общее количество элементов в A и B.

def merge(A, B):
    # Walk A and build a hash table mapping its values to indices.
    amap = {}
    for i, a in enumerate(A):
        amap[a] = i

    # Now walk B building C.
    C = []
    ai = 0
    bi = 0
    for i, b in enumerate(B):
        if b in amap:
            # b is in both lists.
            new_ai = amap[b]
            assert new_ai >= ai  # check for consistent input
            C += A[ai:new_ai]    # add non-shared elements from A
            C += B[bi:i]         # add non-shared elements from B
            C.append(b)          # add the shared element b
            ai = new_ai + 1
            bi = i + 1
    C += A[ai:]  # add remaining non-shared elements from A
    C += B[bi:]  # from B
    return C

A = [1, 2, 'c', 4, 5, 'f', 7]
B = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
print merge(A, B)

(Это просто реализация алгоритма Анона. Обратите внимание, что вы можете проверить несогласованные входные списки без ущерба для производительности и что случайный доступ в списки не надо.)