本人参考网上对冒泡算法的优化，再一次进行的小小优化，欢迎各位指点
* Y0 x- T' Z) ^6 L7 i( a0 S& j
9 N7 S7 t; Q2 F9 h1 i; I$ S

1. void bubble4(uint16_t *arr, uint16_t length)
   3 E4 n0 R* u( ]: L' O4 ?3 O
2. {
   5 L- b, w0 U& Z6 R9 E
3.         uint16_t borden_right = length -1; //右边界初始值
   9 A1 f0 V6 @" X3 f" h; e, U! @2 Z
4.         uint16_t borden_left  = 0;         //左边界初始值为
   
5.         uint16_t lastPos      = 0;         //记录右边界的值
   ) _+ F$ @' U  I9 {
6.         uint16_t prePos       = 0;         //记录左边界的值
   
7.     uint16_t temp;                     //交换的中间变量
   
8.         uint8_t  flag, i, j;               //是否有交换的标志     
   / M8 N/ r+ }9 P4 V
9.    
   
10.    
    
11.         for(i = 0; i < length-1; i++)
    3 ?  `% I$ [9 |7 q2 \
12.     {
    
13.                 flag = 1;
    
14. 
    
15.                 //正向找出最大值
    
16.                 for( j = borden_left; j < borden_right; j++)
    % ?' j  `# {* {
17.         {
    : M& B" K$ R' @) `, A% @
18.                         if(arr[j] > arr[j+1])
    
19.             {
    
20.                 temp     = arr[j];
    
21.                 arr[j]   = arr[j+1];
    
22.                 arr[j+1] = temp;
    
23.                                 flag = 0;
    ' j5 X) {: [8 d+ l
24.                                 lastPos = j;
    
25.                         }
    & F7 C  F7 |' U2 G4 S# d  u
26.                 }
    2 V7 s; |, u% _$ n8 E4 ?
27.         
    3 B4 d/ v: k  e0 b4 \7 ~
28.         //正向没发生交换就证明数组已经排好了
    
29.         if(flag)
    + [7 r, ~9 m& D/ E7 Y
30.         {
    
31.             break;
    
32.         }
    
33.         
      S- b. W1 `9 J0 d  Y8 @% q
34.         borden_right = lastPos;
    / y, o$ g0 q& i1 Y: t
35.    
    $ K2 j$ ~8 F/ X/ ^1 H6 T: A! @2 G
36.                 //逆向找出最小值
    ) f( `2 k0 c( ]# D: \' S" M
37.                 for( j = borden_right; j > borden_left; j--)
    + X: r% }' m5 q
38.         {
    
39.                         if(arr[j] < arr[j-1])
    ! b; B  g0 Q1 M
40.             {
    
41.                 temp     = arr[j];
    ) }6 [  q# z0 Z2 R3 O8 ~, [
42.                 arr[j]   = arr[j-1];
    2 }8 N6 E9 b$ c9 i
43.                 arr[j-1] = temp;
    
44.                                 flag = 0;
    
45.                                 prePos = j;
    5 h" }, i* k/ H) C8 H, }6 h
46.                         }
    
47.                 }
    
48. 
    
49.                 if(flag)
    
50.         {
    , q3 Q) n5 F9 C
51.                         break;
    
52.                 }
    7 L/ S! A, e+ }0 S! P, G
53.        
    
54.                 borden_left  = prePos;
    
55.         
    
56.         //每排序一次都把数组打印出来
    
57. //        for(j = 0; j < length; j++)
    
58. //        {
    # F. z# {( P. T
59. //            USART_SendData(USART1, arr[j]);
    ! g0 n1 ~9 T6 W2 ?" J3 O2 k8 l; D
60. //            while(USART_GetFlagStatus(USART1, USART_FLAG_TC) == RESET);
    
61. //        }
    
62.         }
    . I3 m$ Q$ k9 `+ H5 Q7 P
63. 
    
64. }

复制代码

8 _; H7 G3 ^7 B6 \" w* s

从时间复杂度上，你比原始的冒泡法系数还大一些？

我觉得所谓优化，应该是有明确的对比参数数据的，比如执行时间消耗短了，占用RAM变小了……等等
# {' T& d& v5 o4 U如果楼主能提供这些数据，我觉得更好

直接上选择法吧

时间上会节省，但栈空间就要付出多一点，个人兴趣，实验数据就不发出来了

你这没看出哪有优化，在网上看到过相似的算法, 你这改过的程序，CPU执行的过程，比你不改更花时间，除非是运算的百W级别数组

你有没有测试过具体时间呢，比较下常规的和你改过在 1000个数组排列，耗时大小