C 跳过一个元素的快速排序

所以今天我尝试实现一个快速排序。它几乎可以工作，但不知何故跳过了一个元素

示例：5282334157-5-1-92457614

输出：-5-1-912341445556778

在这种情况下，它跳过

-9

。下面是函数的代码

test = quicksort_asc(0,size,tab,size) // this is function call 

int quicksort_asc(int l, int r, int tab[], int tabSize) //l is first index, r is last index, tabSize is tabsize-1 generally
{
    int i,buffer,lim,pivot,flag=0;
    if(l == r)
        return 0;

    lim = l-1;
    pivot = tab[r-1];
    printf("pivot:%d\n",pivot);
    for (i = l; i <= r-1; ++i)
    {
        if(tab[i] < pivot) {
            lim++;
            buffer = tab[lim];
            tab[lim] = tab[i];
            tab[i] = buffer;
            flag = 1;
        }
    }
    if(flag == 0)
        return 0;
    buffer = tab[lim+1];
    tab[lim+1] = pivot;
    tab[r-1] = buffer;
    quicksort_asc(l,lim+1,tab,lim+1);//left side
    quicksort_asc(lim+1,tabSize,tab,tabSize);//right side

}

test=quicksort\u asc（0，大小，制表符，大小）//这是函数调用
int quicksort_asc（int l，int r，int tab[]，int tabSize）//l是第一个索引，r是最后一个索引，tabSize通常是tabSize-1
{
int i，缓冲区，直线电机，枢轴，标志=0；
如果（l==r）
返回0；
lim=l-1；
枢轴=制表符[r-1]；
printf（“枢轴：%d\n”，枢轴）；
因为（似乎没有人急急忙忙来帮你。）

对于初学者来说，最后一个参数是冗余的

int quicksort_asc(int l, int r, int tab[], int tabSize);
                                           ^^^^^^^^^^^

您只需要指向数组的第一个元素以及起始和结束索引的指针

对于索引，最好使用类型
size\u t
，而不是类型
int

lim = l-1;

然后，让索引具有int类型，尽管您可以使用另一种方法而不使用此表达式语句

所以函数应该声明为

void quicksort_asc( int tab[], int l, int r );

变量
标志
是冗余的。当它等于0时，意味着轴值之前的所有元素都大于或等于它。但是，您必须将轴值与大于或等于轴的第一个元素交换

这个环路

for (i = l; i <= r-1; ++i)

应替换此呼叫

quicksort_asc( lim + 2, r, tab );
               ^^^^^^^  ^^  

因为透视值不包括在此子数组中

这是一个演示程序

#include <stdio.h>

void quicksort_asc( int tab[], int l, int r )
{
    if ( l + 1 < r )
    {
        int lim = l - 1;

        int pivot = tab[r - 1];

        for ( int i = l; i < r - 1; ++i )
        {
            if ( tab[i] < pivot ) 
            {
                lim++;

                int tmp = tab[lim];
                tab[lim] = tab[i];
                tab[i] = tmp;
            }
        }

        tab[r - 1] = tab[lim + 1];
        tab[lim + 1] = pivot;
        quicksort_asc( tab, l, lim + 1 );
        quicksort_asc( tab, lim + 2, r );
    }       
}

int main(void)
{
    int a[] = { 5, 2, 8, 2, 3, 4, 1, 5, 7, -5, -1, -9, 2, 4, 5, 7, 6, 1, 4 };
    const int N = ( int )( sizeof( a ) / sizeof( *a ) );

    for ( int i = 0; i < N; i++ )
    {
        printf( "%d ", a[i] );
    }
    putchar( '\n' );

    quicksort_asc( a, 0, N );

    for ( int i = 0; i < N; i++ )
    {
        printf( "%d ", a[i] );
    }
    putchar( '\n' );

    return 0;
}

请提供一个工作代码，这样我们才能真正提供帮助。你的意思是？检查编辑你在这里有一个极好的学习机会。熟悉基本知识大约需要20分钟，那么短的时间将很快获得巨大的回报。好的，我相信你。我会学习它的部分
2 3 2 1 4
排序不正确另外，你提到了OP代码中的一个冗余迭代。我的代码表示如果你将
if（l！=r）
改为
if（l
在这个例子中，你会从39个递归下降到29个，但仍然得到相同的答案。或者我有什么地方搞砸了吗？@cdlane写l+1lim=l-1

后面的段落是什么意思“好的，让索引具有int类型”）？@S.S.Anne这意味着索引应该具有size\u t类型。在这种情况下，当l等于0时，表达式l-1可能具有非常大的值，因为size\u t是无符号类型。

quicksort_asc(lim+1,tabSize,tab,tabSize);
              ^^^^^ ^^^^^^^

quicksort_asc( lim + 2, r, tab );
               ^^^^^^^  ^^  

#include <stdio.h>

void quicksort_asc( int tab[], int l, int r )
{
    if ( l + 1 < r )
    {
        int lim = l - 1;

        int pivot = tab[r - 1];

        for ( int i = l; i < r - 1; ++i )
        {
            if ( tab[i] < pivot ) 
            {
                lim++;

                int tmp = tab[lim];
                tab[lim] = tab[i];
                tab[i] = tmp;
            }
        }

        tab[r - 1] = tab[lim + 1];
        tab[lim + 1] = pivot;
        quicksort_asc( tab, l, lim + 1 );
        quicksort_asc( tab, lim + 2, r );
    }       
}

int main(void)
{
    int a[] = { 5, 2, 8, 2, 3, 4, 1, 5, 7, -5, -1, -9, 2, 4, 5, 7, 6, 1, 4 };
    const int N = ( int )( sizeof( a ) / sizeof( *a ) );

    for ( int i = 0; i < N; i++ )
    {
        printf( "%d ", a[i] );
    }
    putchar( '\n' );

    quicksort_asc( a, 0, N );

    for ( int i = 0; i < N; i++ )
    {
        printf( "%d ", a[i] );
    }
    putchar( '\n' );

    return 0;
}

5 2 8 2 3 4 1 5 7 -5 -1 -9 2 4 5 7 6 1 4 
-9 -5 -1 1 1 2 2 2 3 4 4 4 5 5 5 6 7 7 8