跳出循环我以前写冒泡的时候就考虑了，只是没实现，因为一个简单的例子就能狠狠的打脸。

｛0，2，3，6，7，8，1，4，5，9｝

void sort( E_T *array, int l, int r )
{
    int minix, maxix;
    int R;
    int c;
    
    c=0;

    for( ; l < r; ++l, --r )
    {
        int mask = 1;
        for( minix = l + 1, maxix = r - 2, R = r - 1; minix <= R; ++minix, --maxix )
        {
            if( array[ l ] > array[ minix ] )
            {
                mask = 0;
                c++;
                E_T temp = array[ l ];
                array[ l ] = array[ minix ];
                array[ minix ] = temp;
            }
            if( array[ R ] < array[ maxix ] )
            {
                mask = 0;
                c++;
                E_T temp = array[ R ];
                array[ R ] = array[ maxix ];
                array[ maxix ] = temp;
            }
        }
        if(mask)
            break;
    }
    
    printf("jiao huan %d ci",c);
    
}

比如万能的 mask

=========================
好吧 不行

[此贴子已经被作者于2018-5-24 11:33编辑过]

考虑楼上的例子。

要跳出循环，我的想法是加一次遍历，但是这样的后果是效率不稳定。

一次扫描同时扫出最大数和最小数，减少了扫描次数。

可以理解成是循环语句跳转需要时间么,就是说从循环结束跳转到开始这样需要一定的时间么,因为这种写法设计到要处理的变量多了,嗯,我只能这样理解了~

最终修改版。

#include <stdio.h>
#include <time.h>
#include <stdlib.h>
typedef int E_T;

void sort( E_T *array, int l, int r );

int main( void )
{
    E_T a[ 10 ] = {9,9,2,3,4,5,6,7,0,0};
  /*  srand( ( unsigned long )time( NULL ) );
    
    for( int i = 0; i < 10; ++i )
    {
        a[ i ] = rand() % 1000;
        printf( "%d ",a[ i ] );
    }*/
    printf( "\n" );
    sort( a, 0, 10 );
    for( int i = 0; i < 10; ++i )
        printf( "%d ", a[ i ] );
    return 0;
}


void sort( E_T *array, int l, int r )
{
    int minix, maxix;
    int R;
    int c;
    int f;
    int s;
    
    s = 0;
    
    if( l >= r )
        return;
    
    
    for( int ix = l; ix < r -1; ix++ )
    {
        if( array[ ix ] <= array[ ix + 1 ] )
            s++;
        else if( array[ ix ] > array[ix + 1 ] )
        {
            s--;
            if( s > 0 )
                break;
        }
        else
            break;
    }
    
    c=0;
    
    if( s == r - l - 1 )
    {
         printf("jiao huan %d ci\n",c);
        return;
    }
    else if( s == l - r + 1)
    {
        for(r -= 1 ; l < r; l++,r-- )
        {
            c++;
            E_T temp = array[ l ];
            array[ l ] = array[ r ];
            array[ r ] = temp;
        }
    }
    else
    {
        for( ; l < r; ++l, --r )
        {
             f = 0;
            for( minix = l + 1, maxix = r - 2, R = r - 1; minix <= R; ++minix, --maxix )
            {
                if( array[ l ] > array[ minix ] )
                {
                    c++;
                    f = 1;
                    E_T temp = array[ l ];
                    array[ l ] = array[ minix ];
                    array[ minix ] = temp;
                }
                if( array[ R ] < array[ maxix ] )
                {
                    c++;
                    f = 1;
                    E_T temp = array[ R ];
                    array[ R ] = array[ maxix ];
                    array[ maxix ] = temp;
                }
            }
            
            if( f != 0 )
                sort( array, l + 1, r - 1 );
        }
    }
    
    printf("jiao huan %d ci\n",c);
    
}

[此贴子已经被作者于2018-5-24 21:24编辑过]

这个就是能够减少比较次数了吧~

如果一次交换后是顺序那么就不用再排了,如果一次交换刚好是逆序,那么就直接把数据倒过来~
但这样减少交换次数却额外增加了比较次数~

    for( int ix = l; ix < r -1; ix++ )
    {
        if( array[ ix ] <= array[ ix + 1 ] )
            s++;   
        else
            break;
    }

这样看看有没有问题~

这几行代码的目的是判断数组是顺序还是逆序用的。当然也可以再加几行，用来判断顺序或逆序的元素有多少个，到乱序的元素时就跳出来。


在细节上还可以再完善。

[此贴子已经被作者于2018-5-24 21:18编辑过]

用一次遍历换N次潜逃循环，怎么算都是值得的。