Python 排序'；端到端'；像这样：[[a，b][b，c][c，e]]

如何对数组列表进行如下排序：

    ((green, yellow]),
    (red, orange),
    (blue, green),
    (yellow, red),
    (black, blue))

    ((black, blue),
    (blue, green),
    (green, yellow),
    (yellow, red),
    (red, orange))

因此，这两个元素首尾相连，如下所示：

    ((green, yellow]),
    (red, orange),
    (blue, green),
    (yellow, red),
    (black, blue))

    ((black, blue),
    (blue, green),
    (green, yellow),
    (yellow, red),
    (red, orange))

---

最容易理解的方法可能是将成对的元组转换为dict，然后从dict读取结果：

>>> arr = (('green', 'yellow'),
...        ('red', 'orange'),
...        ('blue', 'green'),
...        ('yellow', 'red'),
...        ('black', 'blue'))
>>> dct = dict(arr)
>>> result = []
>>> key = min(dct)
>>> while key in dct:
...     result.append((key, dct[key]))
...     key = dct[key]
>>> print(result)
[('black', 'blue'), ('blue', 'green'), ('green', 'yellow'), ('yellow', 'red'), ('red', 'orange')]

---

当它在一对中发现第二个值而不是另一对中相应的第一个值时，这将结束，我认为这是您正在寻找的规则。但如果输入数据中可能存在循环，它将永远循环。要解决此问题，您可以保留一组迄今为止使用过的关键点，并在发现重复时中断：

>>> seen = set()
>>> while key in dct:
...     if key in set: break
...     result.append((key, dct[key]))
...     seen.add(key)
...     key = dct[key]

---

min（dct）

按排序顺序拾取第一个元素。如果你想选择不同的东西，你显然需要不同的东西。以下是一些例子：

successors = {succ for prev, succ in arr}

# Any arbitrary key that starts a chain
key = next(key for key in dct if key not in successors)

# Specifically a random key from among those that start a chain:
key = random.choice(dct.keys() - successors)

---

最容易理解的方法可能是将成对的元组转换为dict，然后从dict读取结果：

>>> arr = (('green', 'yellow'),
...        ('red', 'orange'),
...        ('blue', 'green'),
...        ('yellow', 'red'),
...        ('black', 'blue'))
>>> dct = dict(arr)
>>> result = []
>>> key = min(dct)
>>> while key in dct:
...     result.append((key, dct[key]))
...     key = dct[key]
>>> print(result)
[('black', 'blue'), ('blue', 'green'), ('green', 'yellow'), ('yellow', 'red'), ('red', 'orange')]

---

当它在一对中发现第二个值而不是另一对中相应的第一个值时，这将结束，我认为这是您正在寻找的规则。但如果输入数据中可能存在循环，它将永远循环。要解决此问题，您可以保留一组迄今为止使用过的关键点，并在发现重复时中断：

>>> seen = set()
>>> while key in dct:
...     if key in set: break
...     result.append((key, dct[key]))
...     seen.add(key)
...     key = dct[key]

---

min（dct）

按排序顺序拾取第一个元素。如果你想选择不同的东西，你显然需要不同的东西。以下是一些例子：

successors = {succ for prev, succ in arr}

# Any arbitrary key that starts a chain
key = next(key for key in dct if key not in successors)

# Specifically a random key from among those that start a chain:
key = random.choice(dct.keys() - successors)

---

为了让这项功能发挥作用，您需要假设只有两种唯一的颜色，即不重复的颜色，因此它们无法链接。似乎所有元组都是唯一的，所以如果一种颜色出现两次，它会出现一次第一次和一次第二次。因此，假设您知道要从哪个元组开始，该元组包含唯一的元素，那么您可以循环并添加下一个包含重复颜色的元组

tuples = [('green', 'yellow'),('red', 'orange'),('blue', 'green'),('yellow', 'red'),('black', 'blue')]

sorted_tuples = [tuples[4]]

def sort_tup(original_tup,sort_tup):
    for x in original_tup:
       if sort_tup[-1][1] == x[0]:
            return x

while len(sorted_tuples) < 5:
   sorted_tuples.append(sort_tup(tuples,sorted_tuples))

tuples=[（'green'，'yellow'），（'red'，'orange'），（'blue'，'green'），（'yellow'，'red'），（'black'，'blue'）]
排序的_元组=[元组[4]]
定义排序图（原始排序图、排序图）：
对于原始安装中的x：
如果排序图[-1][1]==x[0]：
返回x
而len（排序的_元组）<5：
排序的\u元组。追加（排序的\u元组（元组，排序的\u元组））

---

这很难看，但在这个问题上没有更多的结构，我认为这是一个相当直截了当的解决方法

为了实现这一点，您需要假设只有两种唯一的颜色，即不重复的颜色，因此它们无法链接。似乎所有元组都是唯一的，所以如果一种颜色出现两次，它会出现一次第一次和一次第二次。因此，假设您知道要从哪个元组开始，该元组包含唯一的元素，那么您可以循环并添加下一个包含重复颜色的元组

tuples = [('green', 'yellow'),('red', 'orange'),('blue', 'green'),('yellow', 'red'),('black', 'blue')]

sorted_tuples = [tuples[4]]

def sort_tup(original_tup,sort_tup):
    for x in original_tup:
       if sort_tup[-1][1] == x[0]:
            return x

while len(sorted_tuples) < 5:
   sorted_tuples.append(sort_tup(tuples,sorted_tuples))

tuples=[（'green'，'yellow'），（'red'，'orange'），（'blue'，'green'），（'yellow'，'red'），（'black'，'blue'）]
排序的_元组=[元组[4]]
定义排序图（原始排序图、排序图）：
对于原始安装中的x：
如果排序图[-1][1]==x[0]：
返回x
而len（排序的_元组）<5：
排序的\u元组。追加（排序的\u元组（元组，排序的\u元组））

---

这很难看，但在这个问题上没有更多的结构，我认为这是一个相当直截了当的解决方法

很好的解决方案，但是您可能需要一种比

min（dct）

更健壮的方法来查找起始值：P@Aran-菲：为什么？这似乎是挑选

黑色

的规则。另外，如果规则类似于“选择使链长度最大化的值，如果存在多个最大链，则任意选择”，我认为OP不会将其称为“排序”。但我可能错了。我就是这样解释这个问题的。但你可能是对的。我想，让我们拭目以待，看看OP对它是否满意。如果它们都包含三个元素，是否仍有可能将它们转换为dict？例如：arr=（‘丑’、‘绿’、‘黄’、（‘狼’、‘红’、‘橙’）、（‘狗’、‘蓝’、‘绿’、（‘手套’、‘黄’、‘红’）、（‘小精灵’、‘黑’、‘蓝’）@NathanTurczan在这种情况下的规则是什么？我假设它类似于每个

三元组[2]

指向下一个

三元组[1]

，在这种情况下，您可以制作一个dict

{triplet[1]：arr}

中三元组的三元组，然后执行

结果。追加（dct[key]）

和

key=dct[key][2]

，或者类似的操作。好的解决方案，但是您可能需要一种比

min（dct）

更健壮的方法来查找起始值：P@Aran-菲：为什么？这似乎是挑选

黑色

的规则。另外，如果规则类似于“选择使链长度最大化的值，如果存在多个最大链，则任意选择”，我认为OP不会将其称为“排序”。但我可能错了。我就是这样解释这个问题的。但你可能是对的。我想，让我们拭目以待，看看OP对它是否满意。如果它们都包含三个元素，是否仍有可能将它们转换为dict？例如：arr=（‘丑’、‘绿’、‘黄’、（‘狼’、‘红’、‘橙’）、（‘狗’、‘蓝’、‘绿’、（‘手套’、‘黄’、‘红’）、（‘小精灵’、‘黑’、‘蓝’）@NathanTurczan在这种情况下的规则是什么？我假设它类似于每个

三元组[2]

指向下一个

三元组[1]

，在这种情况下，您可以在arr}中为三元组创建一个dict

{triplet[1]：triplet for triplet，然后执行
result.append（dct[key]）
和
key=dct[key][2]
，或者类似的操作。选择起点的规则是什么？你说的是“排序”，你的例子选择了排序顺序中第一个的，那么…这就是你想要的吗？或者说，这就像是链条长度最大化的起点？（如果是这样的话，如果有三个起点都给出了长度为2的链，但没有一个起点给出了更长的链，会发生什么情况？任意拾取？引发异常？）或…somet