Python-快速排序递归-如何解决堆栈溢出？

我正在做一个作业，需要编写一个快速排序函数，根据某个键对（nx3）矩阵进行排序

例如，假设用户输入键[2,0,1]。这意味着程序必须首先对第三列进行排序，如果有任何相等的值，它将检查第一列以决定排序。如果值仍然相等，则转到第二列

例如：

key = [2,0,1]

matrix = [["0","1", "1"], ["0","1", "1"], ["1","1", "2"], ["2","0", "1"], ["2","2", "0"]]

预期结果：

[['2', '2', '0'], ['0', '1', '1'], ['0', '1', '1'], ['2', '0', '1'], ['1', '1', '2']]

我使用递归编写了以下代码。对于大小小于1000的矩阵，它可以正常工作。如果我有一个更大的矩阵，由于Python约束，它会给我一个堆栈溢出错误

我抬头一看，意识到我可以用记忆技术来解决这个问题。有人知道如何在我的代码中实现这样的东西吗

def QuickSort (matrix, key, start = 0, end = None):

    if end is None:
        end = len(matrix)-1
    if start < end:
        p = partition(matrix, start, end, key)
        QuickSort(matrix, key, start, p - 1)
        QuickSort(matrix, key, p + 1, end)

    return matrix


def partition (matrix, start, end, ordekeym):

    pivot = matrix[end]
    i = start

    for j in range (start, end):

        if matrix[j][key[0]] < pivot[key[0]]:
            matrix[j], matrix[i] = matrix[i], matrix[j]
            i = i + 1

        if matrix[j][key[0]] == pivot[key[0]] and len(key) == 2:
            if matrix[j][key[1]] < pivot[key[1]]:
                i = i+1

        if matrix[j][key[0]] == pivot[key[0]] and len(key) == 3:
            if matrix[j][key[1]] < pivot[key[1]]:
                i = i + 1
            if matrix[j][key[1]] == pivot[key[1]]:
                if matrix[j][key[2]] < pivot[key[2]]:
                    i = i + 1
                if matrix[j][key[2]] == pivot[key[2]]:
                    break

    matrix[i], matrix[end], = matrix[end], matrix[i]
    return i

print(QuickSort(matrix, key))

def快速排序（矩阵、键、开始=0、结束=无）：
如果结束为无：
结束=透镜（矩阵）-1
如果开始<结束：
p=分区（矩阵、开始、结束、键）
快速排序（矩阵、键、开始、p-1）
快速排序（矩阵、键、p+1、结束）
返回矩阵
def分区（矩阵、开始、结束、顺序）：
枢轴=矩阵[结束]
i=开始
对于范围内的j（开始、结束）：
如果矩阵[j][key[0]

如果您有可用的代码，并且正在寻求一般性的改进，那么这个问题更适合您–确保检查主题：第一。链接到该主题仅对较小的分区使用递归，而对较大的分区使用迭代（循环）。对于使用堆栈的迭代实现，将较大的分区索引推送到堆栈上，并立即处理较小的分区。在这两种情况下，一般的规则是先对较小的分区进行快速排序。请注意，示例是Lomuto分区方案，通常速度更快。