Python list.sort（）和sorted（）等效

这个问题完全是为了学习。我怀疑我是否需要使用它，因为sort（）和sorted（）都存在，但我想学习这里使用的算法/方法

我们有这样一个数组：

test = [
    [2, 2], 
    [1, 2], 
    [1, 1], 
    [3, 3], 
    [1, 3], 
    [2, 3], 
    [3, 2], 
    [2, 1], 
    [3, 1]
]

我想按第二个数字排序，然后按第一个数字排序，反之亦然

通常我会使用

sorted（）

：

或使用

list.sort（）

：

---

如何在不使用上述任何方法的情况下做到这一点。

实际实现在

这里是一个类似的纯Python实现（尽管优化程度较低，等等）

首先，我们需要一个简单的助手函数：

def cmp (a, b):
    if a < b:
        return 1
    elif a == b:
        return 0
    else:
        return -1

如果您对它进行测试，

mysorted

应该像

sorted

一样工作，只是速度较慢

你可以看到，将数组转换成to_compare/orig对，比较你应该比较的部分，然后提取原始数据，这是一个神奇的过程

---

另一个神奇之处在于元组的比较从头到尾都是级联的。

通过编写自己的排序方法，使用标准的排序算法。我建议您从这里选择一个排序算法，并尝试自己实现。Python的排序算法是。中解释了键如何工作的思想。没错，我可以编写排序算法，但我的问题更多的是如何按第二个值排序。在我的例子中，假设我有[2,2]，[2,1]，[1,1]。如果我按第二个数字排序，我将得到[2,1]，[1,1]，[2,2]。现在我想按第一个数字排序得到[1,1]，[2,1]，[2,2]。有没有办法进行上一次排序，或者我必须按第二个数字再次排序。它不会打破原来的那种吗？还是有更好的方法？让我知道，如果你不要求排序算法，你不想使用内置的排序功能，但你想排序。我迷路了。我明白了，这对我来说更有意义了。非常感谢您的回答！

test.sort(key=lambda x: (x[1], x[0]))

def cmp (a, b):
    if a < b:
        return 1
    elif a == b:
        return 0
    else:
        return -1

def _merge (array1, array2, _le):
    i = 0
    j = 0
    answer = []
    while i < len(array1) and j < len(array2):
        if _le(array1[i], array2[j]):
            answer.append(array1[i])
            i += 1
        else:
            answer.append(array2[j])
            j += 1

    while i < len(array1):
        answer.append(array1[i])
        i += 1

    while j < len(array2):
        answer.append(array2[j])
        j += 1

    return answer

def _sorted (array, _le):
    if len(array) < 2:
        return array.copy()
    else:
        k = len(array) // 2
        return _merge(
                _sorted(array[0:k], _le),
                _sorted(array[k:], _le),
                _le
            )

def mysorted (array, key=None, reversed=False):
    _le = le

    if key is not None:
        # Turn the array into pairs of (to_compare, orig)
        array = [(key(x), x) for x in array]
        # Extract compare first pair
        _le = lambda a, b: le(a[0], b[0])

    if reversed:
        _ge = lambda a, b: a == b or not _le(a, b)
        sorted_array = _sorted(array, _ge)
    else:
        sorted_array = _sorted(array, _le)

    if key is not None:
        # Return the orig values in order.
        return [x[1] for x in sorted_array]
    else:
        # All done
        return sorted_array