Python 在最坏的情况下尝试快速排序。它工作正常，但在最坏的情况下发生未知错误。我想

这是关于内存访问的错误（不确定）

我正在尝试对n个不同的元素（n>0）进行快速排序。 对于洗牌数组，即使元素超过数百万，它也能正常运行， 但当n>=4000时，它在最坏的情况下不起作用

问题是什么？如何解决

这是python代码

import random
import time as tm
import sys


def Quick_Sort(A,s,e):

    if s >= e:          
        return


    p = A[s]             #first # of the array is the povot
    i = s               
    j = e


    while i < j:
        while i < e and A[i] <= p:  #finding bigger numbers
            i = i+1
        while j > s and A[j] > p:   #finding smaller numbers
            j = j-1
        if i < j:                   
            A[i], A[j] = A[j], A[i]


    A[s], A[j] = A[j], A[s]         # sort the pivot



    Quick_Sort(A,s,j-1)           #subarray of smaller numbers
    Quick_Sort(A,j+1,e)           #subarray of bigger numbers


if __name__=='__main__':

    sys.setrecursionlimit(10**6) #for expanding recursion limit

    A=[]            
    size = 10000  #size of array
    r_tm = 0

    for i in range(1, size +1):  # n distinct elements
        A.append(i)             

    t=A[size-1]             #worst case
    A[1:size]=A[0:size-1]
    A[0] = t

    #random.shuffle(A)     #it works well


    s_tm = tm.time()
    Quick_Sort(A,0,size-1)
    e_tm = tm.time()

    for i in range(0,size-1):    #for checking array sorted well
        if A[i] > A[i+1]:
            print("Wrong, %d",i)
            break

    r_tm += round(e_tm - s_tm, 3)


    print("size: %d, time: %f" %(size, r_tm))

随机导入
将时间导入为tm
导入系统
def快速分拣（A、s、e）：
如果s>=e：
返回
p=A[s]#数组的第一个#是povot
i=s
j=e
而ip:#找到更小的数
j=j-1
如果iA[i+1]：
打印（“错误，%d”，i）
打破
r_tm+=圆形（e_tm-s_tm，3）
打印（“大小：%d，时间：%f”%（大小，r_tm））

这是C++代码< /P> 贝壳秀 '进程已完成，退出代码为-1073741571'

#include <iostream>
#include <vector>
#include <algorithm>
#include <random>

using namespace std;

void Quick_Sort(vector<int> &A, int s, int e);
int main() {
    vector<int> A;
    int c = 0;
    std::random_device rd;
    std::mt19937 g (rd());

    int size = 4000;

    A.push_back(size);

    for (int i = 1; i < size; i++) {
        A.push_back(i);
    }

    //shuffle(A.begin(),A.end(),g);  //it works well


    Quick_Sort(A, 0, size - 1);


    for (int i = 1; i < size; i++) { //for checking array sorted well
        if (A[i - 1] > A[i]) {
            cout << "Wrong" << endl;
            return 0;
        }
    }

}

void Quick_Sort(vector<int> &A, int s, int e) {
    if (s >= e)         
        return;

    int p = A[s];            //first # of array is the pivot
    int i = s;
    int j = e;
    int tmp = 0;           

    while (i < j) {

        while ((i < e) && (A[i] <= p))      //finding bigger numbers
            i = i + 1;

        while ((j > s) && (A[j] > p))       //finding smaller numbers
            j = j - 1;

        if (i < j) {            
            tmp = A[i];
            A[i] = A[j];
            A[j] = tmp;
        }
    }

    tmp = A[s];    //sort the pivot
    A[s] = A[j]; 
    A[j] = tmp; 


    Quick_Sort(A, s, j - 1);           //subarray of smaller numbers
    Quick_Sort(A, j + 1, e);           //subarray of bigger numbers

}

#包括
#包括
#包括
#包括
使用名称空间std；
无效快速排序（向量&A、整数s、整数e）；
int main（）{
载体A；
int c=0；
std：：随机_装置rd；
标准：MT19937G（rd（））；
int size=4000；
A.推回（尺寸）；
对于（int i=1；iA[i]）{
cout p））//查找较小的数字
j=j-1；
如果（i

这可能是由于堆栈溢出。 在坏的情况下，递归需要O（大小）深度

---

和BTW，这是在C++中实现快速排序的一种完全错误的方式。

< P>避免堆栈溢出、较小部分的递归和较大部分的回环。这将将堆栈复杂度限制为O（log（n）），但最坏情况下的时间复杂度仍然为O（n ^ 2）。问题代码中存在其他问题，与此示例比较。

def qsort(a, lo, hi):
    while(lo < hi):
        p = a[(lo + hi) // 2]   # pivot
        i = lo
        j = hi
        while(i <= j):
            while(a[i] < p):
                i += 1
            while(a[j] > p):
                j -= 1
            if(i > j):
                break
            a[i],a[j] = a[j],a[i]
            i += 1
            j -= 1
        # recurse on smaller part, loop on larger part
        if((j - lo) <= (hi - i)):
            qsort(a, lo, j)
            lo = i
        else:
            qsort(a, i, hi)
            hi = j

def qsort（a、lo、hi）：
而（loj）：
打破
a[i]，a[j]=a[j]，a[i]
i+=1
j-=1
#小部分递归，大部分循环
如果（（j-lo）你好，NANIBOYE，欢迎使用StActExcel！请您精确描述您正在获得的错误。在Python Shell中，CelsSeG97是CalSeGG97，没有错误消息，但是在几秒钟的操作之后shell重新启动。当然，代码的结果没有出现。因此，我用C++编写了一个相同的代码。C++中，它看起来与Python B相似。重要的是我找不到代码'-1073741571'的意思