Python 荷兰国旗分类

我正在尝试使用。我已经尽我所能使这项工作，我真的感到沮丧。你能帮我找一下这些虫子吗

import random

a = []
for i in range(100):
    a.append(random.randint(1, 100))

print(a)
def partion(array, left, right, lPiv, rPiv):
        high = len(array) -1
        p = left
        i = left
        while i < high:
                if array[i] < lPiv and array[i] < rPiv:
                        array[i],array[p]=array[p],array[i]
                        p = p+1
                        i = i+1
                elif array[i] > lPiv and array[i] > rPiv:
                        array[i],array[high]=array[high],array[i]
                        high = high-1
                else:
                        i = i+1

        return [p, high]

def piv(array, left, right):
    aMin = array[left]
    aMax = array[left]

    for i in array:
      if i < aMin:
          aMin = i
      if i > aMax:
          aMax = i
    return [aMin + ((aMax - aMin) /3), aMin + ((aMax-aMin)/3)*2]


def sort(array, left, right, depth):
    apiv = piv(array, left, right)
    part = partion(array, left, right, apiv[0], apiv[1])
    if right-left >= 3:
        piv1 = piv(array, left, part[0])
        part1 = partion(array, left, part[0], piv1[0], piv1[1])
        sort(array, left, part1[0], depth+1)


        piv2 = piv(array, part[0], part[1])
        part2 = partion(array, part[0], part[1], piv2[0], piv2[1])
        sort(array, part[0], part[1])

        piv3 = piv(array, part[1], right)
        part3 = partion(array, part[1], right, piv3[0], piv3[1] )
        sort(array, part[1], right)

    elif right-left < 3:
        if array[right] < array[left]:
            array[right],array[left] = array[left], array[right]
        else:
            return


sort(a, 0, len(a), 1)
print(a)

随机导入
a=[]
对于范围（100）内的i：
a、 追加（random.randint（1100））
印刷品（a）
def分区（阵列、左、右、lPiv、rPiv）：
高=透镜（阵列）-1
p=左
i=左
而我<高：
如果数组[i]lPiv和数组[i]>rPiv：
数组[i]，数组[high]=数组[high]，数组[i]
高=高-1
其他：
i=i+1
回报率[p，高]
def piv（阵列，左，右）：
aMin=数组[左]
aMax=数组[左]
对于数组中的i：
如果我<阿明：
阿明=我
如果i>aMax：
aMax=i
返回[aMin+（（aMax-aMin）/3），aMin+（（aMax-aMin）/3）*2]
def排序（数组、左、右、深度）：
apiv=piv（阵列，左，右）
part=partion（数组，左，右，apiv[0]，apiv[1]）
如果左右>=3：
piv1=piv（阵列，左侧，部分[0]）
part1=分区（数组，左侧，part[0]，piv1[0]，piv1[1]）
排序（数组，左侧，第1部分[0]，深度+1）
piv2=piv（数组，部分[0]，部分[1]）
part2=分区（数组，part[0]，part[1]，piv2[0]，piv2[1]）
排序（数组，部分[0]，部分[1]）
piv3=piv（数组，第[1]部分，右）
part3=分区（数组，part[1]，右，piv3[0]，piv3[1]）
排序（数组，第[1]部分，右侧）
elif右左<3：
如果数组[右]<数组[左]：
数组[右]，数组[左]=数组[左]，数组[右]
其他：
返回
排序（a，0，len（a），1）
印刷品（a）
piv似乎总是返回相同的值，是吗？也许for循环应该在数组[left:right]上，而不是在整个数组上？
代码中的一些错误

sort（）接受4个参数，因此排序（数组，部分[0]，部分[1]）失败。顺便说一句，深度是没有必要的
如果数组[右]<数组[左]：
和
排序（a，0，len（a），1）
。
当右边是数组的长度时，它超出了数组的索引范围
piv应该处理部分而不是整个阵列
如果分区中的数字都相同，
aMin+（（aMax-aMin）/3）
和
aMin+（（aMax-aMin）/3）*2是相同的索引

由于分区只处理一个分区，而不是整个数组，
high=len（array）-1
应该是
high=right-1
part1=partion（数组，左侧，part[0]，piv1[0]，piv1[1]）
错误。Sort（）在数组开始时对数组进行分区，不要在同一递归中进行两次分区。只需调用sort（数组，…）
你的分区算法是错误的，我找不到一个简单的修复方法

这是我的实现

import random
from itertools import islice
a = []
for i in range(100):
    a.append(random.randint(1, 100))

def partition(array, left, right, lPiv, rPiv):
        q = right -1
        p = left
        r = left
        while p<=q:
            if array[p]<=lPiv:
                array[p], array[r] = array[r], array[p]
                p = p+1
                r = r+1
            elif lPiv<array[p]<=rPiv:
                p = p+1
            else:
                array[p], array[q] = array[q], array[p]
                q=q-1

        return (p, q+1)

def piv(array, left, right):
    aMin = min(islice(a,left,right))
    aMax = max(islice(a,left,right))
    return (aMin + ((aMax - aMin) /3.0), aMin + ((aMax-aMin)/3.0)*2)


def sort(array, left, right):
    if right-left >= 3:
        piv_left, piv_right = piv(array, left, right)
        if piv_left == piv_right:
            return
        pt_left, pt_right = partition(array, left, right, piv_left, piv_right)
        sort(array, left, pt_left)
        sort(array, pt_left, pt_right)
        sort(array, pt_right, right)
    elif right-left <3:
        if left<right and array[right-1] < array[left]:
            array[right-1],array[left] = array[left], array[right-1]


sort(a, 0, len(a))
print a

#test
assert( a==sorted(a) )

随机导入
从itertools导入islice
a=[]
对于范围（100）内的i：
a、 追加（random.randint（1100））
def分区（阵列、左、右、lPiv、rPiv）：
q=右-1
p=左
r=左
当你收到错误信息时？如果是，那是什么？这是一个无止境的循环。。。文件“I:/Users/Thomas/Desktop/sort.py”，第49行，在排序（数组，左侧，part1[0]，深度+1）文件“I:/Users/Thomas/Desktop/sort.py”，第49行，在排序（数组，左侧，part1[0]，深度+1）文件“I:/Users/Thomas/Desktop/sort.py”，第40行，in-sort print（array）RuntimeError：调用Python ObjectInFine递归时超出了最大递归深度，这通常意味着递归对象或基本大小写检查有问题。看起来您正在尝试用Python编写Java：(