Sort lists according to the order of another

Question

I have three parallel lists (i.e. the elements in position i of each list are related). I want to sort the first list using the function Sort and make the same changes to the other lists so that I still have parallel lists when finished.

How can I do this?

As an example: Given the lists {2, 3, 1}, {a, b, c}, and {alpha, beta, gamma}, sorting all lists according the first one gives {1, 2, 3}, {c, a, b}, and {gamma, alpha, beta}.

Answer 1

lists = {list1, list2, list3} = {{1, 3, 2}, {a, b, c}, {x, y, z}};

Another option

SortBy[lists\[Transpose], First]\[Transpose]

{{1, 2, 3}, {a, c, b}, {x, z, y}}

Answer 2

You can use combination of Part and Ordering as

list1[[ Ordering @ list2 ]]

to sort list1 in the order of list2.

Examples:

{list1, list2, list3} = {{1, 3, 2}, {a, b, c}, {x, y, z}};
list2[[ Ordering @ list1 ]]

gives

{a, c, b}

and

list3[[ Ordering @ list1 ]]

gives

{x, z, y}

EDIT: Using with lists of lists, to sort the entire array based on the first list:

list = {list1, list2, list3};
list[[ All, Ordering @ list[[1]] ]]

gives

{{1, 2, 3}, {a, c, b}, {x, z, y}}

But ... as I just noticed, this is already covered in @Mr.Wizard's answer long before my edit.

Answer 3

Ordering and Part is more efficient than SortBy and Transpose and it can also be done in one pass as I will demonstrate.

I create three lists of different type as described in the question:

a = RandomInteger[999, 500];
b = RandomReal[1, 500];
c = CharacterRange["a", "z"] ~RandomChoice~ 500;

I use the timeAvg function for testing:

SortBy[{a, b, c}\[Transpose], First]\[Transpose] // timeAvg

{a, b, c}[[All, Ordering@a]] // timeAvg

0.00027456

0.000026944

As can be seen second method is more than an order of magnitude faster on this data.

It is noteworthy that these two forms as shown do not perform the same operation because SortBy[list, func] is not a stable sort. Observe:

lists = {{8, 8, 6, 3, 7},
         {"i", "e", "f", "b", "m"},
         {"q", "x", "u", "w", "z"}};

SortBy[lists\[Transpose], First]\[Transpose]

lists[[All, Ordering @ First @ lists]]

{{3, 6, 7, 8, 8}, {"b", "f", "m", "e", "i"}, {"w", "u", "z", "x", "q"}}

{{3, 6, 7, 8, 8}, {"b", "f", "m", "i", "e"}, {"w", "u", "z", "q", "x"}}

You can see see that SortBy has swapped the positions of "i"/"e" and "q"/"x" in the lists so it is not a minimal reordering. This can be corrected however with a different syntax for SortBy:

SortBy[lists\[Transpose], {First}]\[Transpose]

{{3, 6, 7, 8, 8}, {"b", "f", "m", "i", "e"}, {"w", "u", "z", "q", "x"}}

This syntax also speeds up SortBy, but not enough to be competitive with Ordering:

SortBy[{a, b, c}\[Transpose], {First}]\[Transpose] // timeAvg

0.0001248

Answer 4

This is a more general solution that I came up with some time ago to solve some rearrangement problems. I'm pretty sure that it is slower than any of the solutions above (as it uses ReplacePart), but it is general enough to deal with any kind of ragged partitions. Usage: partitionAs sorts and partitions a list just as a reference list ref is ordered and partitioned.

partitionAs[list_, ref_] := Module[{ord = Ordering@Flatten@ref, 
    pos = Position[ref, Except[_List | List]]}, 
   ReplacePart[ref, Thread[pos -> Flatten[list][[ord]]]]];

ref = {{2, {9}, 0}, {3, 7}, 6, {4, {8, 5}, 1}}
list = {"A", "B", {"C", "D"}, "E", {"F", "G"}, "H", "I", "J"};

partitionAs[list, ref]

{{2, {9}, 0}, {3, 7}, 6, {4, {8, 5}, 1}}

{{"C", {"J"}, "A"}, {"D", "G"}, "I", {"F", {"E", "H"}, "B"}}