如何对 python 中的列表进行排序，以便具有相同 class 的两个值不会是邻居？

Question

我有一个 python 中的类列表，例如list1 = [1, 1, 0, 1, 0, 0, 1, 1] 。 我想对这样的列表进行排序list 2 = list(range(len(list1))) = [0, 1, 2, 3, 4, 5, 6, 7]以便具有相同 class 的两个值不会彼此靠近。 对于我的示例，结果将是[0, 2, 1, 4, 3, 5, 6] 。 第 7 号将被排除在外，因为我需要尽可能地坚持原始列表。 这个任务有排序算法吗？ 我怎样才能有效地实施它？

我如何获得最终名单的详细说明：

1) 将 list2 中的值 0 放入最终结果列表中： res = [0,] 。 它有 class 1 (list1[0])

2) 检查 list2 ("1") class 中的下一个值。 在本例中，它也是 1，因此我们不会将它们放在一起并继续。

3) 检查 list2 ("2") class 中的下一个值。 它 class 0，不等于先前值的 class，所以我们可以 append 结果： res = [0, 2,]

4）现在我将 go 恢复为我之前跳过的值（“1”）并将其添加到最终列表中。 res=[0, 2, 1,] 。 他们现在的类是 [1, 0, 1]。

5) 我们从 list2 转到值“3”。 它有 class 1，所以我们不能将它添加到列表中

6) 从 list2 移至值“4”。 它的 class 是 0，所以我们可以添加它： res = [0, 2, 1, 4,] 。 这些值的类看起来像 [1, 0, 1, 0]

7) Go 回到数值“3”，检查我们现在是否可以添加它。 结果列表中最后一个 class 是 0，“3”有 class 1，所以我们可以添加它。 res = [0, 2, 1, 4, 3,] ，他们的类 = [1, 0, 1, 0, 1]

8) 从list2 移至值“5”。 它有 class 0，将其添加到结果res = [0, 2, 1, 4, 3, 5,] ，它们的类 = [1, 0, 1, 0, 1, 0]

9) 从 list2 移至值“6”。 它有 class 1，所以我将它添加到最终列表中： res = [0, 2, 1, 4, 3, 5, 6] ，它们的类 = [1, 0, 1, 0, 1, 0, 1]

10) 现在我必须检查 list2 中的最后一个值 - “7”。 我无法将它添加到 list6 中，因为这样我的类将如下所示： [1, 0, 1, 0, 1, 0, 1, 1] 我不希望这种情况发生，所以我只是省略了值最终结果中的“7”。

我不明白如何编写这个代码，尤其是当我有超过 2 个类的情况下。

Answer 1

一个简单的解决方案是将每种类型“隔离”到它们自己的列表中，然后在附加时交替它们：

list1 = [1, 1, 0, 1, 0, 0, 1, 1]
sorted_list = []
sorted_list_indices = []

# Isolate each type to their own list of (index, item)
types = {
    'type0': [(ind, x) for ind, x in enumerate(list1) if x == 0],
    'type1': [(ind, x) for ind, x in enumerate(list1) if x == 1]
    }


# Alternate between the lists of each type, starting with the bigger list
alternator = 'type0' if len(types['type0']) > len(types['type1']) else 'type1'

for i in range(0, len(list1)):
    # Break if one of the lists is empty
    if len(types[alternator]) == 0: break
    # Pop the first item from the "current" list and append it to the output
    tup = types[alternator].pop(0)
    sorted_list_indices.append(tup[0])
    sorted_list.append(tup[1])
    # Switch to the other type
    alternator = 'type0' if alternator == 'type1' else 'type1'

print sorted_list
# [1, 0, 1, 0, 1, 0, 1]
print sorted_list_indices
# [0, 2, 1, 4, 3, 5, 6]

更新：这是另一个利用zip内置 function 的示例：

list1 = [1, 1, 0, 1, 0, 0, 1, 1]
sorted_list = []
sorted_list_indices = []

# Isolate each type to their own list of (index, item)
type0 = [(ind, x) for ind, x in enumerate(list1) if x == 0]
# [(2, 0), (4, 0), (5, 0)]
type1 = [(ind, x) for ind, x in enumerate(list1) if x == 1]
# [(0, 1), (1, 1), (3, 1), (6, 1), (7, 1)]

big_list = type0 if len(type0) > len(type1) else type1
small_list = type0 if len(type0) <= len(type1) else type1

# Shrink the big list to make it larger by one at most
big_list = big_list[:len(small_list)+1]

# Use zip to get a list of tuples as (big_list, small_list)
zipped_list = zip(big_list, small_list)
# [((0, 1), (2, 0)), ((1, 1), (4, 0)), ((3, 1), (5, 0))]

# If big_list is indeed larger, we append its last item to our zipped_list
if len(big_list) > len(small_list): zipped_list.append((big_list[-1],))
# [((0, 1), (2, 0)), ((1, 1), (4, 0)), ((3, 1), (5, 0)), ((6, 1),)]

# Flatten the zipped list of tuples
sorted_list = [tup[1] for zipped in zipped_list for tup in zipped]
sorted_list_indices = [tup[0] for zipped in zipped_list for tup in zipped]

print sorted_list
# [1, 0, 1, 0, 1, 0, 1]
print sorted_list_indices
# [0, 2, 1, 4, 3, 5, 6]