本人参考网上对冒泡算法的优化，再一次进行的小小优化，欢迎各位指点

1. void bubble4(uint16_t *arr, uint16_t length)
   
2. {
   
3.         uint16_t borden_right = length -1; //右边界初始值
   8 D. b& s8 ~, A8 J' y, ?  K
4.         uint16_t borden_left  = 0;         //左边界初始值为
   ) u2 e$ }9 }9 J1 H, q% @
5.         uint16_t lastPos      = 0;         //记录右边界的值
   ' m/ n( j/ b4 }1 J, e5 o
6.         uint16_t prePos       = 0;         //记录左边界的值
   
7.     uint16_t temp;                     //交换的中间变量
   
8.         uint8_t  flag, i, j;               //是否有交换的标志     
   
9.    
   
10.    
    
11.         for(i = 0; i < length-1; i++)
    
12.     {
    4 a" `: B5 Z2 ~) |6 I4 P
13.                 flag = 1;
    
14. 
    
15.                 //正向找出最大值
    
16.                 for( j = borden_left; j < borden_right; j++)
    
17.         {
    ( R6 N! A0 x4 |) _
18.                         if(arr[j] > arr[j+1])
    
19.             {
    
20.                 temp     = arr[j];
    6 _- g$ k# r! W. y: l8 \# {
21.                 arr[j]   = arr[j+1];
    % U' d! i% j' o/ V' |
22.                 arr[j+1] = temp;
    
23.                                 flag = 0;
    - f4 N  e9 N: W. s
24.                                 lastPos = j;
    1 c% u) ~9 U2 l2 U7 I+ k
25.                         }
    
26.                 }
    $ c9 E; z2 ^4 E/ d2 h/ j6 m9 R
27.         
    + K4 Y# n, z$ F/ K
28.         //正向没发生交换就证明数组已经排好了
    
29.         if(flag)
    
30.         {
    ! _* o! ^* d$ j8 X$ B+ U& A
31.             break;
    
32.         }
    ) Y. e) T3 Q% J3 ]& e2 K$ R
33.         
    9 \; J. n, `! i6 R0 G
34.         borden_right = lastPos;
    
35.    
    & f- e/ H% {* f
36.                 //逆向找出最小值
    ' E: F2 k, h3 O$ X
37.                 for( j = borden_right; j > borden_left; j--)
    " v0 V* i' x8 q" ?- m3 b
38.         {
    " B: p* Y4 h& e; e, E& }- e6 K& i# m
39.                         if(arr[j] < arr[j-1])
    5 m! H0 d1 S  n) e3 B  P& c+ ?$ r
40.             {
    & P5 e) \, S+ A' M8 Y  l
41.                 temp     = arr[j];
    & d4 o' `7 L8 E+ w: o
42.                 arr[j]   = arr[j-1];
    ; o9 W6 f' e1 m, Z; Z- s
43.                 arr[j-1] = temp;
    
44.                                 flag = 0;
    
45.                                 prePos = j;
    
46.                         }
    " E$ m$ {* Z4 [+ a9 ~
47.                 }
    6 Y  x6 U' e% n8 B+ t6 f
48. 
      A) `6 z5 D- P; T4 P2 k
49.                 if(flag)
    
50.         {
    , F6 H6 t  K* z+ {$ H  R
51.                         break;
    
52.                 }
    3 f( R8 A# ]: d- d- ?5 Z
53.        
    
54.                 borden_left  = prePos;
    : c0 ^+ _1 S1 K; p3 p, W+ K6 {+ D9 Y
55.         
    
56.         //每排序一次都把数组打印出来
    % s6 u- d( D$ I. v
57. //        for(j = 0; j < length; j++)
    
58. //        {
    
59. //            USART_SendData(USART1, arr[j]);
    # B4 C5 k3 p; Q( E" R/ K$ v5 J# \
60. //            while(USART_GetFlagStatus(USART1, USART_FLAG_TC) == RESET);
    " G& s- E( K1 }2 s+ G1 Q4 ?, l2 s0 }
61. //        }
    ) E$ s; v0 Y+ `8 U0 N) C
62.         }
    ) A; o0 n: J# ~2 Q7 {! h
63. 
    
64. }

复制代码

7 @: g3 N7 U: C; ~
  ^% B) ^5 U$ r5 p( v2 }
* i( c7 N; X7 z/ c

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

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

直接上选择法吧

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

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

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