C 选择排序算法能否像冒泡排序那样提前结束循环？

如果我不包含提前终止标志，这个程序将运行良好，但它只需要10次排序就可以对列表进行完全排序，而不是12次排序。但是，当包含终止标志时，它会过早终止排序。按照逻辑，我可以看到这是因为在第三次传递之后，数组的顺序如下：

由于索引i当前为7，因此没有较小的值可交换，因此该标志没有得到分配给它的值1，循环终止。所以我想我的问题是，是否有可能提前打破选择排序算法，并且仍然完全完成排序

#include<stdio.h>
int main()
{
     int list[13]= {23,8,4,7,22,18,39,42,5,88,16,11,3};
     int temp,min,flag;
     printf( "Before Sorting\n" );
     printf( "23 8 4 7 22 18 39 42 5 88 16 11 3\n" );

for( int i=0; i<12; i++ )
    {
        flag = 0;
        min = i;

        for( int j=i+1; j<13; j++ )
            {
                if( list[j]<list[min] )
                    {
                        flag = 1;
                        min = j  ;
                    }
            }

        if( !flag )
            break;

        temp = list[i];
        list[i]=list[min];
        list[min]=temp;

        printf( "\nAfter Pass %d.\n",i+1 );
        for( int i=0; i<13; i++ )
            printf( "%d ",list[i] );

        printf( "\n" );
    }

return 0;
}

#包括
int main（）
{
int list[13]={23,8,4,7,22,18,39,42,5,88,16,11,3}；
内部温度，最小值，标志；
printf（“排序前”）；
printf（“238472218394258816113\n”）；
对于（inti=0；i，冒泡排序几乎没有什么可取之处，它最好的地方是它的名字

泡沫排序似乎没有什么值得推荐的，除了一个吸引人的名字和它导致一些有趣的理论问题的事实

事实上，从维基百科上可以看到：

在简单平均caseΘ（n²）算法中，选择排序几乎总是优于冒泡排序和gnome排序

选择排序没有变化——它的运行时间不依赖于排序。对于另一个运行时间可变的简单O（n²）算法，请参见。
气泡排序几乎没有什么可取之处，最妙的是它的名称。Donald Knuth说过

泡沫排序似乎没有什么值得推荐的，除了一个吸引人的名字和它导致一些有趣的理论问题的事实

事实上，从维基百科上可以看到：

在简单平均caseΘ（n²）算法中，选择排序几乎总是优于冒泡排序和gnome排序

选择排序没有变化-其运行时间不依赖于排序。有关另一个运行时间可变的简单O（n²）算法，请参阅。
确实可以。下面是这样一个实现

int selsort(int v[], int n){

  bool sorted = false; // v not known to be sorted
  int  i = 0;          // i smallest elements in place 

  while(!sorted){
    // find min v[i..n-1]
    // check if v[i..n-1] is sorted

    int  j   = i+1;
    int  min = i;    // position of minimum of v[i..j-1]
    sorted   = true; // v[i..j-1] sorted

    while(j<n){
      if(v[j]<v[min]) min = j;        // update min
      if(v[j]<v[j-1]) sorted = false; // update sorted
      j++;
    }

    if (!sorted){
      // place min v[i..n-1] in v[i]
      int aux = v[i];
      v[i]    = v[min];
      v[min]  = aux;      

      i++;
    }
  }

  return EXIT_SUCCESS;
}

只要您不必更新内部循环中的最小值，您的标志将保持在
0
。因此，第一个位置具有最小值的任何段都将被视为已排序。
确实可以。下面是这样一个实现

int selsort(int v[], int n){

  bool sorted = false; // v not known to be sorted
  int  i = 0;          // i smallest elements in place 

  while(!sorted){
    // find min v[i..n-1]
    // check if v[i..n-1] is sorted

    int  j   = i+1;
    int  min = i;    // position of minimum of v[i..j-1]
    sorted   = true; // v[i..j-1] sorted

    while(j<n){
      if(v[j]<v[min]) min = j;        // update min
      if(v[j]<v[j-1]) sorted = false; // update sorted
      j++;
    }

    if (!sorted){
      // place min v[i..n-1] in v[i]
      int aux = v[i];
      v[i]    = v[min];
      v[min]  = aux;      

      i++;
    }
  }

  return EXIT_SUCCESS;
}

只要您不必更新内部循环中的最小值，您的标志将保持在
0
。因此，第一个位置具有最小值的任何段都将被视为已排序。
您不能像这样中断。这里，当前值7是列表中的最小值，因此它是（应该）的不与任何内容交换，但这并没有说明剩余文件的任何内容（除非所有值都已知为>=7）。与其尝试优化选择排序，不如使用时间复杂度更高的智能排序算法。在选择排序中，您唯一可以跳过的是交换。您不能这样中断。此处，当前值7是列表中的最低值，因此它（应该）是这样的不与任何内容交换，但这并不能说明剩余文件的任何内容（除非已知所有值均大于等于7）。与其尝试优化选择排序，不如使用时间复杂度更高的智能排序算法。在选择排序中，唯一可以跳过的是交换。