Algorithm 如何根据任意顺序对列表进行排序

我搜索了一个相关的问题，但没有找到。所以我的问题是如何根据任意顺序对数组进行排序。例如，假设排序为：

order_of_elements = ['cc', 'zz', '4b', '13']

以及我要排序的列表：

list_to_be_sorted = ['4b', '4b', 'zz', 'cc', '13', 'cc', 'zz']

因此，结果必须是：

ordered_list = ['cc', 'cc', 'zz', 'zz', '4b', '4b', '13']

请注意，参考列表（元素的顺序）描述了排序，我不要求根据参考列表的字母排序索引进行排序

您可以假设

order\u of_elements

array包含所有可能的元素

---

任何伪代码都是受欢迎的。

实现这一点的一种简单而实用的方法是为元素的

顺序数组计算索引查找表，并将索引用作排序键：

order_index_table = { item: idx for idx, item in enumerate(order_of_elements) }
ordered_list = sorted(list_to_be_sorted, key=lambda x: order_index_table[x])

该表将订单查找减少到
O（1）
（摊销），因此不会改变排序的时间复杂性

（当然，它确实假设
列表中所有要排序的元素都以元素的
顺序存在；如果不一定如此，则需要在lambda键中使用默认返回值。）实现这一点的一种简单而简洁的方法是为
元素的顺序数组计算索引查找表，并将索引用作排序键：

order_index_table = { item: idx for idx, item in enumerate(order_of_elements) }
ordered_list = sorted(list_to_be_sorted, key=lambda x: order_index_table[x])

该表将订单查找减少到
O（1）
（摊销），因此不会改变排序的时间复杂性

（当然，它确实假设
列表中所有要排序的元素都以元素的
顺序存在；如果不一定如此，则需要在lambda键中使用默认返回值。）
因为可能的元素数量有限，并且如果这些元素是可散列的，您可以使用一种计数排序

将
order\u of_elements
中的所有元素作为键放在hashmap中，计数器作为值。遍历您的
列表以进行排序
，增加与当前元素对应的计数器。要构建
有序的\u列表
，请遍历元素的
顺序
，并将每个当前元素添加到该元素计数器指示的次数

hashmap hm;
for e in order_of_elements {
    hm.add(e, 0);
}

for e in list_to_be_sorted {
    hm[e]++;
}

list ordered_list;
for e in order_of_elements {
    list.append(e, hm[e]); // Append hm[e] copies of element e
}

由于可能的元素数量有限，如果这些元素是可散列的，那么可以使用一种计数排序

将
order\u of_elements
中的所有元素作为键放在hashmap中，计数器作为值。遍历您的
列表以进行排序
，增加与当前元素对应的计数器。要构建
有序的\u列表
，请遍历元素的
顺序
，并将每个当前元素添加到该元素计数器指示的次数

hashmap hm;
for e in order_of_elements {
    hm.add(e, 0);
}

for e in list_to_be_sorted {
    hm[e]++;
}

list ordered_list;
for e in order_of_elements {
    list.append(e, hm[e]); // Append hm[e] copies of element e
}

方法：

创建一个辅助数组，该数组将保存“元素的顺序”索引
对辅助数组进行排序

2.1在对辅助数组排序时，重新排列主数组中的值

方法：

创建一个辅助数组，该数组将保存“元素的顺序”索引
对辅助数组进行排序

2.1在对辅助数组排序时，重新排列主数组中的值

任何复杂度要求？实际上我的问题很简单，所以对我来说没有任何要求，但我只是想知道是否有一个特定的算法或方法来满足任何复杂度要求？实际上我的问题很简单，所以对我来说没有任何要求，但我只是想知道是否有一个特定的算法或方法满足这个要求假设元素的顺序包含所有可能的元素。感谢您指出，outI做了一个隐含的假设，即元素的顺序包括所有可能的元素。谢谢你指出了很好的解决方案，谢谢。只是出于好奇，这里的复杂性是O（n）吗？假设追加操作是O（1）？确实是。您将遍历元素的顺序两次，并遍历列表一次。Hashmap插入和查找的复杂度是摊销不变的。Append（一个元素的）在链表上是常量，在数组上是摊销常量，在预先调整大小的数组上是常量。因此，总的来说，复杂性是分期摊销的
O（n）
，使用hashmap的常规计数排序也是如此（而不是
O（n log n）
进行常规的基于比较的排序）。很好的解决方案，谢谢。只是出于好奇，这里的复杂性是O（n）吗？假设追加操作是O（1）？确实是。您将遍历元素的顺序两次，并遍历列表一次。Hashmap插入和查找的复杂度是摊销不变的。Append（一个元素的）在链表上是常量，在数组上是摊销常量，在预先调整大小的数组上是常量。因此，总体而言，复杂性是分期摊销的
O（n）
，使用hashmap的常规计数排序也是如此（而不是基于比较的常规排序的
O（n log n）
）。