基于两个列表的差异创建指令列表

Question

I have two lists (A,B) with values and I want to create an instructions list of operations which will change list A into B.
There are no duplicates in the lists but the order is important.
Example:

 A              B
 ================
 1              5
 2              4
 3              6
 4              3
                1
                7

I'm looking for an efficient algorithm which will generate the minimal list of instructions such as:
Delete at, Insert at, Move from to (at, from and to are locations in the array)

For the above example: (indexes starts from 1)

                       1 2 3 4
Move from 1 to 4    -> 2 3 4 1
Del 1               -> 3 4 1
Insert 5 location 1 -> 5 3 4 1
Move from 3 to 2    -> 5 4 3 1
Insert 6 location 3 -> 5 4 6 3 1
Insert 7 location 6 -> 5 4 6 3 1 7

If there is Java ready algorithm it will be great, but other solutions are welcomed as well. In real life scenario the lists contain java objects which are comparable.

Answer 1

Here's an O(n log n)-time algorithm that computes a shortest edit sequence, where n is the total length of the two lists. First, delete entries from A that are not in B, recording them as deletions. Second, delete entries from B that are not in A, recording them in reverse order as insertions. Clearly all of these operations are necessary.

Now we have a list A' that needs to be transformed into one of its permutations B'. The shortest edit sequence consists solely of moves, since an insert/delete operation must have a counterpart, and such a pair can be replaced by one move. Let's assume for the sake of exposition that A' is in sorted order; for the implementation, we could implement a custom comparator.

Consider a shortest move sequence. The elements not moved must appear in order in B', ie, they constitute an increasing subsequence of B'. To compute a shortest edit sequence, use dynamic programming to find a longest increasing subsequence of B' in time O(n log n). Move all of the other elements appropriately. Most of the implementation complexity here is bookkeeping, though life is a lot easier if you can tolerate a quadratic-time implementation.