标签：一次循环   sizeof   最大值   amp   void   循环   一个   i+1   分析   

冒泡排序

前置知识

• 确定数组需要传入两个参数：数组的首地址和数组元素的个数

• 冒泡规则，假设一个int a[5]的数组，升序规则如下

  ? 第一次排序:

  1. a[0]与a[1]比较，大的值放在a[1]，小的值放在a[0];

  2. a[1]与a[2]比较，大的值放在a[2]，小的值放在a[1];

  3. a[2]与a[3]比较，大的值放在a[3]，小的值放在a[2];

  4. a[3]与a[4]比较，大的值放在a[4]，小的值放在a[3];

  5. 第一次排序结果为取出最大值放在a[4]；

     第二次排序：

  6. a[0]与a[1]比较，大的值放在a[1]，小的值放在a[0];

  7. a[1]与a[2]比较，大的值放在a[2]，下的值放在a[1];

  8. a[2]与a[3]比较，大的值放在a[3]，小的值放在a[2];

  9. 第二次排序的结果为取出剩余元素中的最大值放在a[3]中；

  第三次排序：

  1. a[0]与a[1]比较，大的值放在a[1]，小的值放在a[0];
  2. a[1]与a[2]比较，大的值放在a[2]，下的值放在a[1];
  3. 第三次排序的结果为取出剩余元素中的最大值放在a[2]中；

  ? 第四次排序：

  1. a[0]与a[1]比较，大的值放在a[1]，小的值放在a[0];
  2. 第四次排序的结果为取出剩余元素中的最大值放在a[1]中；
  3. 最小值自然放在了a[0]；

• 由冒泡规则分析得n个元素排序，需要排n-1次

排序分析一

• 嵌套两层循环，第一层每次都是比较数组的前两个元素

• 第二层从第二个元素开始，按照排序规则依次往后两两比较，大的放后面，小的放前面

• 第二层for循环第一次循环结束之后将数组长度-1，继续第一层for循环，依次反复，直到数组长度为2时排序结束

• 代码如下：

  #include <stdio.h>
  
  void sort1(int * pArr, int len)
  {
      int i, j, max, new_len = len;
      for(i = 0; i < len-1; len--)
      {
          if(pArr[i] < pArr[i+1])
          {
              max = pArr[i+1];
          }
          else
          {
              max = pArr[i];
              pArr[i]   = pArr[i+1];
              pArr[i+1] = max;
          }
          for (j = 2; j < len; j ++)
          {
              if(pArr[j] < max)
              {
                  pArr[j-1] = pArr[j];
                  pArr[j] = max;
              }
              else
              {
                  max = pArr[j];
              }
          }
      }
  
       for(i = 0; i < new_len; i ++)
       {
           printf("%d\t", *(pArr+i));
       }
  }
  
  int main(void)
  {
      int a[6] = {2, 3, 1, -10, 10, 100};
      sort(a, sizeof(a)/sizeof(int));
      
      return 0;
  }
  

排序分析二

• 两层循环，第一层用来确定总体循环次数并限制第二层循环执行次数

• 第二层用来按照升序进行两两对比，大的放后面，小的放前面

• 第二层循环次数以第一层来限制，第二层每整体循环完一次之后循环执行次数就会少一次

• 代码如下：

  void sort2(int * pArr, int len)
  {
      int i, j, max;
      for(i = 0; i < len-1; ++i )
      {
          for(j = 0; j < len-1-i; ++j )
          {
              if(pArr[j] > pArr[j+1])
              {
                  max = pArr[j];
                  pArr[j] = pArr[j+1];
                  pArr[j+1] = max;
              }
          }
      }
      for(i = 0; i < len; i ++)
       {
           printf("%d\t", *(pArr+i));
       }
  
  }
  
  int main(void)
  {
      int a[6] = {2, 3, 1, -10, 10, 100};
  
      sort2(&a[0], sizeof(a)/sizeof(int));
  
      return 0;
  }
  

排序算法之冒泡排序

标签：一次循环   sizeof   最大值   amp   void   循环   一个   i+1   分析   

原文地址：https://www.cnblogs.com/jiaqinbi/p/12942027.html