C++ 函数递归调用时的堆栈溢出

我正在尝试创建一个串排序算法，当我再次尝试递归调用它时，它会给我堆栈溢出错误

递归调用是将数组排序为两个已排序数组（preme、NoNpreme）的地方。然后我把它们合并成一个。 我尝试过处理条件，我发现数组在只有1个元素的情况下被排序，这就是我递归的出口。但它不起作用，我也不知道为什么

我的算法：

int* urediSPrameni(int* a, int n)
{
    if (n <= 1)
        return a;

    int pe=a[0];
    int* preme = new int[n];
    preme[0] = a[0];
    int j = 1;
    int k = 0;
    int* NoNpreme = new int[n];
    for(int i=0;i<n;i++)
    {
        if (a[i] > pe)
        {
            pe = a[i];
            preme[j] = a[i];
            j++;
        }
        else
        {
            NoNpreme[k] = a[i];
            k++;
        }
    }
    NoNpreme = urediSPrameni(NoNpreme, k);


    // My merge algorithm:

    //Zlivanje
    int h = 0;//NoNpreme
    int s = 0;//Preme
    int i = 0;
    while (h < k && s < j)
    {
            if (preme[h] <= NoNpreme[s])
            {
                a[i] = preme[h];
                s++;
            }
            else
            {
                a[i] = NoNpreme[s];
                h++;
            }
            i++;
    }
    if (h > k)
    {
        for (int b = s;b < j;b++)
        {
            a[i] = NoNpreme[b];
            i++;
        }
    }
    else
    {
        for (int b = h;b < k;b++)
        {
            a[i] = preme[b];
            i++;
        }
    }
    return a;
}

int*urediSPrameni（int*a，int-n）
{
如果（n您将
a
的第一个元素分配给
pe
，并将该元素的副本存储到
preme
中。当根据
pe
的哪一侧将
a
的元素排序到单独的数组中时，您再次从元素0开始（您已经将其放置到
preme
），因为
if（a[i]>pe）
将为false，将此元素放入
非preme
。一旦数组到达有多个元素的点，并且第一个元素是最小的，所有元素都将复制到
非preme
。之后的每个递归调用都将执行相同的操作，因此递归将永远不会结束，您将无法继续堆栈空间不足

解决方案是使用第二个元素启动for循环：

for (int i = 1; i < n; i++)

for（int i=1；i
NoNpreme=urediSPrameni（NoNpreme，k）；
应该是
return-urediSPrameni（NoNpreme，k）；
并且它会泄漏大量内存，因为您没有
删除[]
您分配给
new[]
的内存。好的。所以我在返回之前删除了数组1行，并将return-NoNpreme=urediSPrameni（NoNpreme，k）放在了位置但它仍然会溢出。@πάνταῥεῖ 我认为合并部分是同一个函数的延续。在这个地方返回将导致函数的其余部分永远无法到达。那么我如何修复它呢？
for (int i = 1; i < n; i++)